diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index b9de11a6..72a93c76 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -29,3 +29,6 @@ jobs: - name: Run Tests run: make test_unit + + - name: Verify bidirectional legacy transcript vectors + run: ./testdata/legacy_transcript/verify.sh diff --git a/CHANGELOG.md b/CHANGELOG.md index 2e5902eb..b9b10b1d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -34,26 +34,67 @@ belongs to PR #2 (the base BNB hardening integration) unless it is tagged with a - **PR #5** — removal of EdDSA and ECDSA resharing protocols (stacked on PR #4). - **PR #6** — remaining BNB cryptographic hardening follow-ups (stacked on PR #5). - **PR #7** — signing round-9 decommitment validation and related fixes (stacked on PR #6). +- **PR #9** — immutable per-party legacy/security-v2 transcript selection and + exact historical legacy compatibility (stacked on PR #7). ### ⚠️ Compatibility — read before upgrading -**This release is a protocol/wire compatibility break and must be rolled out as a -coordinated protocol upgrade.** Fiat-Shamir proof challenges now use tagged hashing, -session context, and fixed-width message encoding. Parties running pre-upgrade code -**cannot** interoperate with upgraded parties in the same keygen or signing ceremony, -even though the Go API remains source-compatible. - -Do not mix pre- and post-upgrade parties in one ceremony; all participants must run the -upgraded build simultaneously. - -Two new caller obligations are enforced at runtime (see Breaking Changes 1 and 2): -1. Set a per-ceremony session nonce before `Start()`. -2. Pass a positive `fullBytesLen` to every signing constructor. +**Security-v2 is a protocol/wire compatibility break.** Its Fiat-Shamir proof +challenges use tagged hashing, session context, and fixed-width message +encoding, so a security-v2 party cannot interoperate with a historical party. + +PR #9 adds an explicit incremental-rollout mode. A party in +`ProtocolModeLegacy` reproduces the historical untagged challenges, including +the exact Schnorr ZK/ZKV `HashToN` input ordering and modular reduction, and can +therefore share a legacy ceremony with the pre-upgrade binary. A ceremony must +still be homogeneous by transcript mode: mixing legacy and security-v2 in one +run fails cryptographic verification, and there is no negotiation, downgrade, +fallback, or retry between modes. + +Three caller obligations are enforced at runtime (see Breaking Changes 1 and 2 +and the PR #9 entry below): +1. Select exactly one protocol mode before constructing a local party. +2. In security-v2, set a unique per-ceremony session nonce; in legacy, leave it unset. +3. Pass a positive `fullBytesLen` to every signing constructor. + +#### PR #9. Explicit dual-mode transcript contract +- **What:** ECDSA keygen/signing parameters require an explicit immutable + `ProtocolModeLegacy` or `ProtocolModeSecurityV2`. Legacy round code calls the + historical no-session proof APIs; security-v2 round code calls the tagged, + session-bound APIs. `schnorr.NewZKProof` / `NewZKVProof` and `Verify` reproduce + the exact `2e712689` `HashToN` transcript. `New*WithSession` rejects nil and + non-nil empty sessions, and `VerifyWithSession` returns false for either, so + an ambiguous empty value can never select a transcript. DLN, range, + Bob/BobWC, ModProof, and FactorProof keep their existing optional-session + shape: no argument is legacy; one non-empty argument is security-v2. + Legacy Bob/BobWC proof generation also restores PRIOR's exact `tau` and + relatively-prime Paillier `gamma` sampling ranges, and its verifier retains + PRIOR's honest response range: legacy samples `gamma` below `N`, whereas + security-v2 samples it below `q^7`; applying the latter bound to historical + proofs rejects valid mixed-version signing transcripts. +- **Break type:** Runtime/source-compatible configuration obligation. A local + party constructed without selecting a mode fails closed. A mode cannot be + changed after construction, security-v2 requires a session nonce, and legacy + refuses one. +- **Motivation:** Preserve byte-compatible pre-cutover ceremonies during an + incremental binary rollout without weakening the post-cutover session-bound + transcript or allowing an in-flight downgrade. +- **Provenance:** `threshold-original`, PR #9. Historical oracle: + `threshold-network/tss-lib@2e712689cfbeefede15f95a0ec7112227d86f702`. +- **Qualification:** `crypto/schnorr/testdata/legacy_transcript_vectors.json` + records fixed public points, legacy/security-v2 challenges, proof scalars, + deterministic round-4/round-6 wire messages, source identities/digests, and + a SHA-256 sidecar. `testdata/legacy_transcript` adds independent bidirectional + PRIOR/R1 oracles and raw vectors for DLN, range, Bob/BobWC, ModProof, and + FactorProof, including the serialized protocol messages that carry them. + Cross-verification uses the historical formulas or the module pinned to + `2e712689`; it does not infer compatibility from two parties running the new + implementation. ### Breaking changes -#### 1. Session nonce is now mandatory and fails closed -- **What:** ECDSA keygen and ECDSA signing now require a positive session nonce. Each +#### 1. Session nonce is mandatory in security-v2 and forbidden in legacy +- **What:** ECDSA keygen and ECDSA signing in security-v2 require a positive session nonce. Each protocol's `Start()` (round 1) returns an error if `Parameters.SetSessionNonce` / `SetSessionNonceBytes` was not called, e.g. `"keygen requires tss.Parameters.SetSessionNonce(...) before Start"` @@ -69,10 +110,12 @@ Two new caller obligations are enforced at runtime (see Breaking Changes 1 and 2 fail-closed-with-no-fallback decision being `threshold-original`. (Note: the threshold base had no SSID machinery at all; the "previous zero / `SHA512_256(messageBytes)` fallback" described in upstream history never shipped in this fork's base.) -- **Migration:** Before `Start()`, on the constructing goroutine, call +- **Migration:** Select `ProtocolModeSecurityV2`, then before constructing the + local party call `params.SetSessionNonce()` or `params.SetSessionNonceBytes(<>=16-byte high-entropy session ID>)`. All parties in a run - must agree on the same value. + must agree on the same value. A legacy party selects `ProtocolModeLegacy` and + must not set a nonce. #### 2. `fullBytesLen` is required at runtime for signing - **What:** The ECDSA signing constructors (`NewLocalParty`, `NewLocalPartyWithKDD`) accept @@ -93,11 +136,14 @@ Two new caller obligations are enforced at runtime (see Breaking Changes 1 and 2 - **What:** Challenge derivation for DLN (`crypto/dlnproof`), Schnorr (`crypto/schnorr`), MtA `ProofBob`/`ProofBobWC` (`crypto/mta/proofs.go`), and `RangeProofAlice` (`crypto/mta/range_proof.go`) now uses length-delimited tagged hashing - (`common.SHA512_256i_TAGGED`) plus optional session context. **The challenge bytes change - unconditionally** — even on the default/nil-session path — because the underlying hash - construction itself changed. Per-party proof contexts also append a fixed-width `uint64` - party index so party 0 no longer collapses to the bare SSID. -- **Break type:** Wire/protocol (old and new proofs do not cross-verify). + (`common.SHA512_256i_TAGGED`) plus session context in security-v2. The + no-session legacy path retains the exact historical construction and input + list; the challenge bytes change only when security-v2 is selected. Per-party + security-v2 proof contexts also append a fixed-width `uint64` party index so + party 0 no longer collapses to the bare SSID. +- **Break type:** Wire/protocol in security-v2 (legacy and security-v2 proofs do + not cross-verify). The explicit legacy mode is byte-compatible with the + historical transcript. - **Motivation:** Domain separation binds each proof to its session/sub-protocol context, defeating cross-protocol and cross-session proof replay. The MtA path additionally binds `NTilde, h1, h2` into the transcript so a malicious verifier cannot swap ring-Pedersen @@ -105,8 +151,9 @@ Two new caller obligations are enforced at runtime (see Breaking Changes 1 and 2 - **Provenance:** `BNB #252` (`3d95e54`), `BNB #256` (`1a14f3a`), `BNB #257` (`ff989bf`, tagged hashing), `BNB b59ed36` (DLN/MtA session context); party-index append is `threshold-original`. -- **Migration:** Coordinated network-wide upgrade; no mixed old/new parties. Any persisted - pre-upgrade proofs are not re-verifiable. +- **Migration:** Use legacy for work anchored before the coordinated cutover and + security-v2 for work anchored at or after it. All parties in one ceremony use + the same mode. Historical proofs remain re-verifiable through the legacy API. #### 4. Tagged Fiat-Shamir for Paillier ModProof / FactorProof (active on the protocol path) - **What:** `ModProof`/`ModVerify` and `FactorProof`/`FactorVerify` diff --git a/README.md b/README.md index e835e4c5..ceaab629 100644 --- a/README.md +++ b/README.md @@ -126,15 +126,48 @@ When you build a transport, it should offer a broadcast channel as well as point Within your transport, each message should be wrapped with a **session ID** that is unique to a single run of the keygen or signing rounds. This session ID should be agreed upon out-of-band and known only by the participating parties before the rounds begin. Upon receiving any message, your program should make sure that the received session ID matches the one that was agreed upon at the start. -The same session ID should be bound into the protocol parameters before constructing local parties: +The proof-transcript mode must be selected explicitly before constructing an +ECDSA keygen or signing party. New ceremonies should use the session-bound +security-v2 mode and bind the same session ID into the protocol parameters: ```go params := tss.NewParameters(curve, ctx, thisParty, len(parties), threshold) +params.SetProtocolMode(tss.ProtocolModeSecurityV2) params.SetSessionNonceBytes([]byte(sessionID)) ``` All parties in the run must use the same high-entropy session ID of at least 16 bytes, and it must be unique to the ceremony. Keygen and signing fail closed if no session nonce is set; reusing a session ID across otherwise identical ceremonies reintroduces transcript-splicing risk. +`ProtocolModeLegacy` exists only for coordinated compatibility with peers that +use the historical untagged GG20 transcript. A ceremony must be homogeneous: +legacy and security-v2 parties cannot interoperate. The selected mode is frozen +when the local party is constructed and cannot change while the protocol is in +flight. + +The low-level proof APIs follow the same unambiguous split. The historical +generic APIs (for example `schnorr.NewZKProof` / `ZKProof.Verify`) reproduce the +exact pre-hardening `HashToN` transcript. Their `WithSession` counterparts are +security-v2-only, require a non-empty session, and never interpret nil or an +empty slice as legacy. DLN, MtA range/Bob/BobWC, ModProof, and FactorProof retain +their source-compatible optional session argument: omitting the argument is +legacy, while supplying one requires a non-empty value and selects the tagged +transcript. The legacy Bob/BobWC path also restores the historical `tau` and +relatively-prime Paillier `gamma` sampling ranges; security-v2 retains its +hardened `q^3*N-tilde` and `q^7` ranges. + +The checked-in bidirectional compatibility oracle and release test commands +are: + +```sh +./testdata/legacy_transcript/verify.sh +go test ./crypto/schnorr ./ecdsa/signing ./ecdsa/keygen -count=20 +go test ./... -count=1 +``` + +On slower builders, preserve the package list and repeat count while extending +only Go's harness timeout, for example `-timeout=30m`. The default ten-minute +timeout can expire while the keygen package is still generating safe primes. + Additionally, there should be a mechanism in your transport to allow for "reliable broadcasts", meaning parties can broadcast a message to other parties such that it's guaranteed that each one receives the same message. There are several examples of algorithms online that do this by sharing and comparing hashes of received messages. Timeouts and errors should be handled by your application. The method `WaitingFor` may be called on a `Party` to get the set of other parties that it is still waiting for messages from. You may also get the set of culprit parties that caused an error from a `*tss.Error`. diff --git a/crypto/dlnproof/proof.go b/crypto/dlnproof/proof.go index 14215214..5cf15e69 100644 --- a/crypto/dlnproof/proof.go +++ b/crypto/dlnproof/proof.go @@ -50,7 +50,7 @@ func NewDLNProof(h1, h2, x, p, q, N *big.Int, session ...[]byte) *Proof { alpha[i] = modN.Exp(h1, a[i]) } msg := append([]*big.Int{h1, h2, N}, alpha[:]...) - c := common.SHA512_256i_TAGGED(fsSessionDLNProof(Session), msg...) + c := proofChallenge(Session, msg...) t := [Iterations]*big.Int{} cIBI := new(big.Int) for i := range t { @@ -87,7 +87,7 @@ func (p *Proof) Verify(h1, h2, N *big.Int, session ...[]byte) bool { } } msg := append([]*big.Int{h1, h2, N}, p.Alpha[:]...) - c := common.SHA512_256i_TAGGED(fsSessionDLNProof(Session), msg...) + c := proofChallenge(Session, msg...) cIBI := new(big.Int) for i := 0; i < Iterations; i++ { cI := c.Bit(i) @@ -102,6 +102,13 @@ func (p *Proof) Verify(h1, h2, N *big.Int, session ...[]byte) bool { return true } +func proofChallenge(session []byte, values ...*big.Int) *big.Int { + if session == nil { + return common.SHA512_256i(values...) + } + return common.SHA512_256i_TAGGED(fsSessionDLNProof(session), values...) +} + func optionalSession(session [][]byte) []byte { if len(session) == 0 { return nil diff --git a/crypto/dlnproof/proof_test.go b/crypto/dlnproof/proof_test.go index 576f16f7..9b9243b6 100644 --- a/crypto/dlnproof/proof_test.go +++ b/crypto/dlnproof/proof_test.go @@ -9,8 +9,25 @@ package dlnproof import ( "math/big" "testing" + + "github.com/bnb-chain/tss-lib/common" ) +func TestLegacyChallengeMatchesHistoricalTranscript(t *testing.T) { + values := []*big.Int{ + big.NewInt(2), + big.NewInt(3), + big.NewInt(5), + big.NewInt(7), + } + + expected := common.SHA512_256i(values...) + actual := proofChallenge(nil, values...) + if expected.Cmp(actual) != 0 { + t.Fatalf("legacy challenge changed: expected %v, got %v", expected, actual) + } +} + func TestDLNProofRejectsEmptySessionTag(t *testing.T) { assertPanics(t, func() { _ = NewDLNProof(nil, nil, nil, nil, nil, nil, []byte{}) diff --git a/crypto/mta/legacy_bob_compatibility_test.go b/crypto/mta/legacy_bob_compatibility_test.go new file mode 100644 index 00000000..89fba68a --- /dev/null +++ b/crypto/mta/legacy_bob_compatibility_test.go @@ -0,0 +1,229 @@ +package mta + +import ( + "crypto/elliptic" + "math/big" + "testing" + + "github.com/bnb-chain/tss-lib/common" + "github.com/bnb-chain/tss-lib/crypto" + "github.com/bnb-chain/tss-lib/crypto/paillier" + "github.com/bnb-chain/tss-lib/ecdsa/keygen" + "github.com/bnb-chain/tss-lib/tss" +) + +// TestLegacyBobVerifierAcceptsHistoricalGammaRange pins a historical proof +// shape the security-v2 verifier intentionally rejects. PRIOR and the restored +// legacy prover sample gamma as a unit below the 2048-bit Paillier modulus; +// the security-v2 prover samples below q^7 instead. The proof is otherwise +// generated from the exact historical equations with fixed test-only witnesses +// and blinders. +func TestLegacyBobVerifierAcceptsHistoricalGammaRange(t *testing.T) { + fixtures, _, err := keygen.LoadKeygenTestFixtures(2) + if err != nil { + t.Fatal(err) + } + owner := fixtures[0] + aux := fixtures[1] + pk := &owner.PaillierSK.PublicKey + ec := tss.EC() + + x := big.NewInt(7) + y := big.NewInt(11) + r := firstSmallUnit(pk.N, 2) + c1 := fixedPaillierEncryption(pk, big.NewInt(5), firstSmallUnit(pk.N, 3)) + modNSquared := common.ModInt(pk.NSquare()) + c2 := modNSquared.Mul( + modNSquared.Exp(c1, x), + modNSquared.Mul( + modNSquared.Exp(pk.Gamma(), y), + modNSquared.Exp(r, pk.N), + ), + ) + + legacy := fixedHistoricalBobProof( + ec, + pk, + aux.NTildei, + aux.H1i, + aux.H2i, + c1, + c2, + x, + y, + r, + nil, + ) + if !legacy.ProofBob.Verify( + ec, + pk, + aux.NTildei, + aux.H1i, + aux.H2i, + c1, + c2, + ) { + t.Fatal("legacy Bob verifier rejected a proof in PRIOR's gamma range") + } + + X := crypto.ScalarBaseMult(ec, x) + legacyWC := fixedHistoricalBobProof( + ec, + pk, + aux.NTildei, + aux.H1i, + aux.H2i, + c1, + c2, + x, + y, + r, + X, + ) + if !legacyWC.Verify( + ec, + pk, + aux.NTildei, + aux.H1i, + aux.H2i, + c1, + c2, + X, + ) { + t.Fatal("legacy BobWC verifier rejected a proof in PRIOR's gamma range") + } + + q := ec.Params().N + q3 := new(big.Int).Exp(q, big.NewInt(3), nil) + q7 := new(big.Int).Exp(q, big.NewInt(7), nil) + if legacy.T1.Cmp(q7) <= 0 || legacyWC.T1.Cmp(q7) <= 0 { + t.Fatal("fixture does not exercise PRIOR's wider gamma range") + } + // BobMid samples the T1 witness y below q^5, so the exact honest legacy + // range is gamma + e*y < N + q^6. + legacyMaxT1 := new(big.Int).Add(pk.N, new(big.Int).Mul(q3, q3)) + if legacy.T1.Cmp(legacyMaxT1) >= 0 || legacyWC.T1.Cmp(legacyMaxT1) >= 0 { + t.Fatal("fixture exceeds the historical honest T1 bound") + } + if legacy.S1.Cmp(q3) >= 0 || legacyWC.S1.Cmp(q3) >= 0 { + t.Fatal("fixture accidentally exceeds the shared S1 bound") + } + + session := []byte("R01/security-v2/bob/range") + if legacy.ProofBob.Verify( + ec, + pk, + aux.NTildei, + aux.H1i, + aux.H2i, + c1, + c2, + session, + ) || legacyWC.Verify( + ec, + pk, + aux.NTildei, + aux.H1i, + aux.H2i, + c1, + c2, + X, + session, + ) { + t.Fatal("historical Bob proof crossed into security-v2") + } +} + +func fixedHistoricalBobProof( + ec elliptic.Curve, + pk *paillier.PublicKey, + nTilde, h1, h2, c1, c2, x, y, r *big.Int, + X *crypto.ECPoint, +) *ProofBobWC { + q := ec.Params().N + q3 := new(big.Int).Exp(q, big.NewInt(3), nil) + qNTilde := new(big.Int).Mul(q, nTilde) + q3NTilde := new(big.Int).Mul(q3, nTilde) + + alpha := new(big.Int).Rsh(new(big.Int).Set(q3), 1) + rho := new(big.Int).Rsh(new(big.Int).Set(qNTilde), 2) + sigma := new(big.Int).Rsh(new(big.Int).Set(qNTilde), 3) + // PRIOR sampled tau below q*NTilde. + tau := new(big.Int).Sub(qNTilde, big.NewInt(1)) + rhoPrime := new(big.Int).Rsh(new(big.Int).Set(q3NTilde), 2) + beta := firstSmallUnit(pk.N, 5) + // This is a valid PRIOR gamma (< pk.N and coprime to it) but is wider + // than q^7 for the 2048-bit fixture modulus. + gamma := new(big.Int).Sub(pk.N, big.NewInt(1)) + + var u *crypto.ECPoint + if X != nil { + u = crypto.ScalarBaseMult(tss.EC(), alpha) + } + modNTilde := common.ModInt(nTilde) + z := modNTilde.ExpMulExp(h1, x, h2, rho) + zPrime := modNTilde.ExpMulExp(h1, alpha, h2, rhoPrime) + transcriptT := modNTilde.ExpMulExp(h1, y, h2, sigma) + modNSquared := common.ModInt(pk.NSquare()) + v := modNSquared.Exp(c1, alpha) + v = modNSquared.Mul(v, modNSquared.Exp(pk.Gamma(), gamma)) + v = modNSquared.Mul(v, modNSquared.Exp(beta, pk.N)) + w := modNTilde.ExpMulExp(h1, gamma, h2, tau) + + e := bobProofChallenge( + nil, + q, + pk, + nTilde, + h1, + h2, + c1, + c2, + X, + u, + z, + zPrime, + transcriptT, + v, + w, + ) + sResponse := common.ModInt(pk.N).Mul( + common.ModInt(pk.N).Exp(r, e), + beta, + ) + + return &ProofBobWC{ + ProofBob: &ProofBob{ + Z: z, + ZPrm: zPrime, + T: transcriptT, + V: v, + W: w, + S: sResponse, + S1: common.AddMul(alpha, e, x), + S2: common.AddMul(rhoPrime, e, rho), + T1: common.AddMul(gamma, e, y), + T2: common.AddMul(tau, e, sigma), + }, + U: u, + } +} + +func fixedPaillierEncryption( + pk *paillier.PublicKey, + message, randomness *big.Int, +) *big.Int { + modNSquared := common.ModInt(pk.NSquare()) + return modNSquared.Mul( + modNSquared.Exp(pk.Gamma(), message), + modNSquared.Exp(randomness, pk.N), + ) +} + +func firstSmallUnit(modulus *big.Int, start int64) *big.Int { + result := big.NewInt(start) + for new(big.Int).GCD(nil, nil, result, modulus).Cmp(big.NewInt(1)) != 0 { + result.Add(result, big.NewInt(1)) + } + return result +} diff --git a/crypto/mta/proofs.go b/crypto/mta/proofs.go index 6536339d..e2eac28c 100644 --- a/crypto/mta/proofs.go +++ b/crypto/mta/proofs.go @@ -58,14 +58,30 @@ func ProveBobWC(ec elliptic.Curve, pk *paillier.PublicKey, NTilde, h1, h2, c1, c // 2. rho := common.GetRandomPositiveInt(qNTilde) sigma := common.GetRandomPositiveInt(qNTilde) - tau := common.GetRandomPositiveInt(q3NTilde) + var tau *big.Int + if Session == nil { + // The legacy transcript samples tau below q*N-tilde. Keep that exact + // distribution for byte-compatible proof generation; security-v2 uses + // the wider q^3*N-tilde range. + tau = common.GetRandomPositiveInt(qNTilde) + } else { + tau = common.GetRandomPositiveInt(q3NTilde) + } // 3. rhoPrm := common.GetRandomPositiveInt(q3NTilde) // 4. beta := common.GetRandomPositiveRelativelyPrimeInt(pk.N) - gamma := common.GetRandomPositiveInt(q7) + var gamma *big.Int + if Session == nil { + // Historical Bob proofs sample gamma as a unit modulo the Paillier + // modulus. Besides reproducing PRIOR proof bytes, this is why the legacy + // verifier must accept T1 above q^7. + gamma = common.GetRandomPositiveRelativelyPrimeInt(pk.N) + } else { + gamma = common.GetRandomPositiveInt(q7) + } // 5. u := crypto.NewECPointNoCurveCheck(ec, zero, zero) // initialization suppresses an IDE warning @@ -97,17 +113,23 @@ func ProveBobWC(ec elliptic.Curve, pk *paillier.PublicKey, NTilde, h1, h2, c1, c w = modNTilde.Mul(w, modNTilde.Exp(h2, tau)) // 11-12. e' - var e *big.Int - { // derive the Fiat-Shamir challenge by reducing the hash mod q - var eHash *big.Int - // X is nil if called by ProveBob (Bob's proof "without check") - if X == nil { - eHash = common.SHA512_256i_TAGGED(fsSessionBob(Session), append(pk.AsInts(), NTilde, h1, h2, c1, c2, z, zPrm, t, v, w)...) - } else { - eHash = common.SHA512_256i_TAGGED(fsSessionBobWC(Session), append(pk.AsInts(), NTilde, h1, h2, X.X(), X.Y(), c1, c2, u.X(), u.Y(), z, zPrm, t, v, w)...) - } - e = common.ModReduceHash(q, eHash) - } + e := bobProofChallenge( + Session, + q, + pk, + NTilde, + h1, + h2, + c1, + c2, + X, + u, + z, + zPrm, + t, + v, + w, + ) // 13. modN := common.ModInt(pk.N) @@ -223,6 +245,22 @@ func (pf *ProofBobWC) Verify(ec elliptic.Curve, pk *paillier.PublicKey, NTilde, q3NTilde := new(big.Int).Mul(q3, NTilde) maxS2 := new(big.Int).Lsh(q3NTilde, 1) maxT2 := new(big.Int).Set(maxS2) + // The session-bound verifier historically accepted T1 == q^7; express the + // exclusive upper bound as q^7 + 1 so the shared >= check below preserves + // that behavior exactly. + maxT1 := new(big.Int).Add(q7, big.NewInt(1)) + if Session == nil { + // The historical prover sampled gamma in [1, pk.N), while the + // security-v2 prover samples it below q^7. Since T1 = e*y + gamma + // with e < q and the MtA blinding value y < q^5, an honest legacy + // response is below pk.N + q^6. + // Applying the security-v2 q^7 cap to a PRIOR proof rejects almost + // every legitimate 2048-bit gamma and breaks mixed-binary legacy + // signing. Keep a finite legacy-specific cap so adversarial exponents + // remain bounded without rewriting the historical acceptance range. + q6 := new(big.Int).Mul(q3, q3) + maxT1 = new(big.Int).Add(pk.N, q6) + } if !common.IsInIntervalPositive(pf.Z, NTilde) { return false @@ -284,7 +322,7 @@ func (pf *ProofBobWC) Verify(ec elliptic.Curve, pk *paillier.PublicKey, NTilde, if pf.S2.Cmp(maxS2) >= 0 { return false } - if pf.T1.Cmp(q7) > 0 { + if pf.T1.Cmp(maxT1) >= 0 { return false } if pf.T2.Cmp(maxT2) >= 0 { @@ -292,23 +330,31 @@ func (pf *ProofBobWC) Verify(ec elliptic.Curve, pk *paillier.PublicKey, NTilde, } // 1-2. e' - var e *big.Int - { // derive the Fiat-Shamir challenge by reducing the hash mod q - var eHash *big.Int - // X is nil if called on a ProveBob (Bob's proof "without check") - if X == nil { - eHash = common.SHA512_256i_TAGGED(fsSessionBob(Session), append(pk.AsInts(), NTilde, h1, h2, c1, c2, pf.Z, pf.ZPrm, pf.T, pf.V, pf.W)...) - } else { - if !X.ValidateBasic() || !crypto.SameCurve(ec, X.Curve()) { - return false - } - if !pf.U.ValidateBasic() || !crypto.SameCurve(ec, pf.U.Curve()) { - return false - } - eHash = common.SHA512_256i_TAGGED(fsSessionBobWC(Session), append(pk.AsInts(), NTilde, h1, h2, X.X(), X.Y(), c1, c2, pf.U.X(), pf.U.Y(), pf.Z, pf.ZPrm, pf.T, pf.V, pf.W)...) + if X != nil { + if !X.ValidateBasic() || !crypto.SameCurve(ec, X.Curve()) { + return false + } + if !pf.U.ValidateBasic() || !crypto.SameCurve(ec, pf.U.Curve()) { + return false } - e = common.ModReduceHash(q, eHash) } + e := bobProofChallenge( + Session, + q, + pk, + NTilde, + h1, + h2, + c1, + c2, + X, + pf.U, + pf.Z, + pf.ZPrm, + pf.T, + pf.V, + pf.W, + ) if e.Sign() == 0 { return false } @@ -372,6 +418,83 @@ func (pf *ProofBobWC) Verify(ec elliptic.Curve, pk *paillier.PublicKey, NTilde, return true } +func bobProofChallenge( + session []byte, + q *big.Int, + pk *paillier.PublicKey, + nTilde, h1, h2, c1, c2 *big.Int, + x, u *crypto.ECPoint, + z, zPrime, t, v, w *big.Int, +) *big.Int { + if session == nil { + if x == nil { + return common.HashToN( + q, + append(pk.AsInts(), c1, c2, z, zPrime, t, v, w)..., + ) + } + return common.HashToN( + q, + append( + pk.AsInts(), + x.X(), + x.Y(), + c1, + c2, + u.X(), + u.Y(), + z, + zPrime, + t, + v, + w, + )..., + ) + } + + if x == nil { + challengeHash := common.SHA512_256i_TAGGED( + fsSessionBob(session), + append( + pk.AsInts(), + nTilde, + h1, + h2, + c1, + c2, + z, + zPrime, + t, + v, + w, + )..., + ) + return common.ModReduceHash(q, challengeHash) + } + + challengeHash := common.SHA512_256i_TAGGED( + fsSessionBobWC(session), + append( + pk.AsInts(), + nTilde, + h1, + h2, + x.X(), + x.Y(), + c1, + c2, + u.X(), + u.Y(), + z, + zPrime, + t, + v, + w, + )..., + ) + return common.ModReduceHash(q, challengeHash) +} + // ProveBob.Verify implements verification of Bob's proof without check "VerifyMta_Bob" used in the MtA protocol from GG18Spec (9) Fig. 11. func (pf *ProofBob) Verify(ec elliptic.Curve, pk *paillier.PublicKey, NTilde, h1, h2, c1, c2 *big.Int, session ...[]byte) bool { if pf == nil { diff --git a/crypto/mta/range_proof.go b/crypto/mta/range_proof.go index 6598787c..a8718921 100644 --- a/crypto/mta/range_proof.go +++ b/crypto/mta/range_proof.go @@ -86,8 +86,7 @@ func ProveRangeAlice(ec elliptic.Curve, pk *paillier.PublicKey, c, NTilde, h1, h w = modNTilde.Mul(w, modNTilde.Exp(h2, gamma)) // 8-9. e' - eHash := common.SHA512_256i_TAGGED(fsSessionRangeAlice(Session), append(pk.AsInts(), NTilde, h1, h2, c, z, u, w)...) - e := common.ModReduceHash(q, eHash) + e := rangeProofChallenge(Session, q, pk, NTilde, h1, h2, c, z, u, w) modN := common.ModInt(pk.N) s := modN.Exp(r, e) @@ -196,8 +195,18 @@ func (pf *RangeProofAlice) Verify(ec elliptic.Curve, pk *paillier.PublicKey, NTi } // 1-2. e' - eHash := common.SHA512_256i_TAGGED(fsSessionRangeAlice(Session), append(pk.AsInts(), NTilde, h1, h2, c, pf.Z, pf.U, pf.W)...) - e := common.ModReduceHash(q, eHash) + e := rangeProofChallenge( + Session, + q, + pk, + NTilde, + h1, + h2, + c, + pf.Z, + pf.U, + pf.W, + ) if e.Sign() == 0 { return false } @@ -235,6 +244,25 @@ func (pf *RangeProofAlice) Verify(ec elliptic.Curve, pk *paillier.PublicKey, NTi return true } +func rangeProofChallenge( + session []byte, + q *big.Int, + pk *paillier.PublicKey, + nTilde, h1, h2, c, z, u, w *big.Int, +) *big.Int { + if session == nil { + // Historical GG20 transcript. The auxiliary modulus and generators + // were not included in the challenge input. + return common.HashToN(q, append(pk.AsInts(), c, z, u, w)...) + } + + challengeHash := common.SHA512_256i_TAGGED( + fsSessionRangeAlice(session), + append(pk.AsInts(), nTilde, h1, h2, c, z, u, w)..., + ) + return common.ModReduceHash(q, challengeHash) +} + func (pf *RangeProofAlice) ValidateBasic() bool { return pf.Z != nil && pf.U != nil && diff --git a/crypto/mta/range_proof_test.go b/crypto/mta/range_proof_test.go index 92add050..885e4716 100644 --- a/crypto/mta/range_proof_test.go +++ b/crypto/mta/range_proof_test.go @@ -31,6 +31,31 @@ func TestProofSessionRejectsEmptyTag(t *testing.T) { }) } +func TestLegacyRangeChallengeMatchesHistoricalTranscript(t *testing.T) { + q := tss.EC().Params().N + pk := &paillier.PublicKey{N: big.NewInt(17)} + c := big.NewInt(19) + z := big.NewInt(23) + u := big.NewInt(29) + w := big.NewInt(31) + + expected := common.HashToN(q, append(pk.AsInts(), c, z, u, w)...) + actual := rangeProofChallenge( + nil, + q, + pk, + big.NewInt(37), + big.NewInt(41), + big.NewInt(43), + c, + z, + u, + w, + ) + + assert.Equal(t, 0, expected.Cmp(actual)) +} + func TestProveRangeAlice(t *testing.T) { q := tss.EC().Params().N diff --git a/crypto/mta/share_protocol_test.go b/crypto/mta/share_protocol_test.go index f581adb4..dd9354bf 100644 --- a/crypto/mta/share_protocol_test.go +++ b/crypto/mta/share_protocol_test.go @@ -27,6 +27,79 @@ const ( testPaillierKeyLength = 2048 ) +func TestLegacyBobChallengesMatchHistoricalTranscript(t *testing.T) { + q := tss.EC().Params().N + pk := &paillier.PublicKey{N: big.NewInt(17)} + c1 := big.NewInt(19) + c2 := big.NewInt(23) + z := big.NewInt(29) + zPrime := big.NewInt(31) + transcriptT := big.NewInt(37) + v := big.NewInt(41) + w := big.NewInt(43) + + expected := common.HashToN( + q, + append(pk.AsInts(), c1, c2, z, zPrime, transcriptT, v, w)..., + ) + actual := bobProofChallenge( + nil, + q, + pk, + big.NewInt(47), + big.NewInt(53), + big.NewInt(59), + c1, + c2, + nil, + nil, + z, + zPrime, + transcriptT, + v, + w, + ) + assert.Equal(t, 0, expected.Cmp(actual)) + + x := crypto.ScalarBaseMult(tss.EC(), big.NewInt(2)) + u := crypto.ScalarBaseMult(tss.EC(), big.NewInt(3)) + expectedWithCheck := common.HashToN( + q, + append( + pk.AsInts(), + x.X(), + x.Y(), + c1, + c2, + u.X(), + u.Y(), + z, + zPrime, + transcriptT, + v, + w, + )..., + ) + actualWithCheck := bobProofChallenge( + nil, + q, + pk, + big.NewInt(47), + big.NewInt(53), + big.NewInt(59), + c1, + c2, + x, + u, + z, + zPrime, + transcriptT, + v, + w, + ) + assert.Equal(t, 0, expectedWithCheck.Cmp(actualWithCheck)) +} + func TestShareProtocol(t *testing.T) { q := tss.EC().Params().N diff --git a/crypto/schnorr/legacy_compatibility_test.go b/crypto/schnorr/legacy_compatibility_test.go new file mode 100644 index 00000000..5ed3ac08 --- /dev/null +++ b/crypto/schnorr/legacy_compatibility_test.go @@ -0,0 +1,457 @@ +package schnorr_test + +import ( + "crypto/sha256" + "encoding/hex" + "encoding/json" + "fmt" + "math/big" + "os" + "testing" + + "github.com/bnb-chain/tss-lib/common" + "github.com/bnb-chain/tss-lib/crypto" + "github.com/bnb-chain/tss-lib/crypto/commitments" + "github.com/bnb-chain/tss-lib/crypto/schnorr" + "github.com/bnb-chain/tss-lib/ecdsa/signing" + "github.com/bnb-chain/tss-lib/tss" +) + +const ( + legacyVectorPath = "testdata/legacy_transcript_vectors.json" + legacyVectorSHA256 = "2dec0490c875396c8161b4b5c522f8f451d6a987174194e22f6883741f6acffb" + zkDomain = "tss-lib.threshold.schnorr.zk|" + zkvDomain = "tss-lib.threshold.schnorr.zkv|" +) + +type vectorPoint struct { + X string `json:"x"` + Y string `json:"y"` +} + +type vectorProof struct { + Alpha vectorPoint `json:"alpha"` + T string `json:"t"` + U string `json:"u"` +} + +type legacyTranscriptVectors struct { + SchemaVersion int `json:"schema_version"` + Provenance struct { + HistoricalModule string `json:"historical_module"` + HistoricalSchnorrSourceSHA256 string `json:"historical_schnorr_source_sha256"` + RegressionBase string `json:"regression_base"` + RegressionSourceSHA256 string `json:"regression_source_sha256"` + Curve string `json:"curve"` + Encoding string `json:"encoding"` + } `json:"provenance"` + SecurityV2Session string `json:"security_v2_session"` + ZK struct { + PrivateScalar string `json:"private_scalar"` + Nonce string `json:"nonce"` + PublicPoint vectorPoint `json:"public_point"` + LegacyChallenge string `json:"legacy_challenge"` + LegacyProof vectorProof `json:"legacy_proof"` + SecurityV2Challenge string `json:"security_v2_challenge"` + SecurityV2Proof vectorProof `json:"security_v2_proof"` + LegacyRound4Wire string `json:"legacy_round4_wire"` + } `json:"zk"` + ZKV struct { + RScalar string `json:"r_scalar"` + S string `json:"s"` + L string `json:"l"` + NonceA string `json:"nonce_a"` + NonceB string `json:"nonce_b"` + R vectorPoint `json:"r"` + V vectorPoint `json:"v"` + LegacyChallenge string `json:"legacy_challenge"` + LegacyProof vectorProof `json:"legacy_proof"` + SecurityV2Challenge string `json:"security_v2_challenge"` + SecurityV2Proof vectorProof `json:"security_v2_proof"` + LegacyRound6Wire string `json:"legacy_round6_wire"` + } `json:"zkv"` +} + +func loadLegacyTranscriptVectors(t *testing.T) legacyTranscriptVectors { + t.Helper() + + raw, err := os.ReadFile(legacyVectorPath) + if err != nil { + t.Fatal(err) + } + digest := sha256.Sum256(raw) + if got := hex.EncodeToString(digest[:]); got != legacyVectorSHA256 { + t.Fatalf("fixture digest = %s, want %s", got, legacyVectorSHA256) + } + + var fixture legacyTranscriptVectors + if err := json.Unmarshal(raw, &fixture); err != nil { + t.Fatal(err) + } + if fixture.SchemaVersion != 1 { + t.Fatalf("fixture schema = %d, want 1", fixture.SchemaVersion) + } + if fixture.Provenance.HistoricalModule != + "github.com/threshold-network/tss-lib@2e712689cfbeefede15f95a0ec7112227d86f702" { + t.Fatalf("unexpected historical provenance: %s", fixture.Provenance.HistoricalModule) + } + if fixture.Provenance.HistoricalSchnorrSourceSHA256 != + "e96a7c9cacf18b684e1f88bc5e7c6673cd341c224ae460abe7dd77db88dd05aa" { + t.Fatalf("unexpected historical source digest: %s", fixture.Provenance.HistoricalSchnorrSourceSHA256) + } + if fixture.Provenance.RegressionBase != + "github.com/threshold-network/tss-lib@d847ce0030193ccf5dbec0097571dcce5a2a5cf6" { + t.Fatalf("unexpected regression provenance: %s", fixture.Provenance.RegressionBase) + } + if fixture.Provenance.RegressionSourceSHA256 != + "0d1c6f095abf2e8ad8e393b7b00705f72ddd03eb1fb23aedbba1987857d2cf6d" { + t.Fatalf("unexpected regression source digest: %s", fixture.Provenance.RegressionSourceSHA256) + } + + return fixture +} + +func vectorInt(t *testing.T, value string) *big.Int { + t.Helper() + result, ok := new(big.Int).SetString(value, 16) + if !ok { + t.Fatalf("invalid vector integer %q", value) + } + return result +} + +func pointFromVector(t *testing.T, value vectorPoint) *crypto.ECPoint { + t.Helper() + point, err := crypto.NewECPoint( + tss.EC(), + vectorInt(t, value.X), + vectorInt(t, value.Y), + ) + if err != nil { + t.Fatal(err) + } + return point +} + +func taggedChallenge(tag string, session []byte, values ...*big.Int) *big.Int { + q := tss.EC().Params().N + domain := append([]byte(tag), session...) + return common.ModReduceHash(q, common.SHA512_256i_TAGGED(domain, values...)) +} + +// TestLegacyZKCrossVerification pins both directions against the historical +// formula. The fixture is a PRIOR-style proof built from fixed test-only x/a; +// the generated half calls the R1 public legacy API and verifies it with an +// independent copy of PRIOR's verifier formula. Running the package with +// -count=20 repeats both directions rather than using two homogeneous R1 +// parties as the legacy oracle. +func TestLegacyZKCrossVerification(t *testing.T) { + fixture := loadLegacyTranscriptVectors(t) + ec := tss.EC() + q := ec.Params().N + g := crypto.NewECPointNoCurveCheck(ec, ec.Params().Gx, ec.Params().Gy) + x := vectorInt(t, fixture.ZK.PrivateScalar) + X := pointFromVector(t, fixture.ZK.PublicPoint) + alpha := pointFromVector(t, fixture.ZK.LegacyProof.Alpha) + proof := &schnorr.ZKProof{Alpha: alpha, T: vectorInt(t, fixture.ZK.LegacyProof.T)} + + challenge := common.HashToN( + q, + X.X(), X.Y(), g.X(), g.Y(), alpha.X(), alpha.Y(), + ) + if challenge.Cmp(vectorInt(t, fixture.ZK.LegacyChallenge)) != 0 { + t.Fatalf("historical ZK challenge = %x, want %s", challenge, fixture.ZK.LegacyChallenge) + } + if !proof.Verify(X) { + t.Fatal("PRIOR-generated ZK fixture did not verify with the R1 legacy API") + } + + for i := 0; i < 20; i++ { + generated, err := schnorr.NewZKProof(x, X) + if err != nil { + t.Fatal(err) + } + if !historicalVerifyZK(generated, X) { + t.Fatalf("R1 legacy ZK proof %d did not verify with the historical formula", i) + } + } +} + +func historicalVerifyZK(proof *schnorr.ZKProof, X *crypto.ECPoint) bool { + ec := X.Curve() + q := ec.Params().N + g := crypto.NewECPointNoCurveCheck(ec, ec.Params().Gx, ec.Params().Gy) + c := common.HashToN( + q, + X.X(), X.Y(), g.X(), g.Y(), proof.Alpha.X(), proof.Alpha.Y(), + ) + tG := crypto.ScalarBaseMult(ec, proof.T) + Xc := X.ScalarMult(c) + right, err := proof.Alpha.Add(Xc) + return err == nil && right.Equals(tG) +} + +// TestLegacyZKVCrossVerification is the ZKV counterpart of the ZK oracle +// above, including a PRIOR fixture and R1-generated proofs checked by the +// historical verifier formula. +func TestLegacyZKVCrossVerification(t *testing.T) { + fixture := loadLegacyTranscriptVectors(t) + ec := tss.EC() + q := ec.Params().N + g := crypto.NewECPointNoCurveCheck(ec, ec.Params().Gx, ec.Params().Gy) + R := pointFromVector(t, fixture.ZKV.R) + V := pointFromVector(t, fixture.ZKV.V) + s := vectorInt(t, fixture.ZKV.S) + l := vectorInt(t, fixture.ZKV.L) + alpha := pointFromVector(t, fixture.ZKV.LegacyProof.Alpha) + proof := &schnorr.ZKVProof{ + Alpha: alpha, + T: vectorInt(t, fixture.ZKV.LegacyProof.T), + U: vectorInt(t, fixture.ZKV.LegacyProof.U), + } + + challenge := common.HashToN( + q, + V.X(), V.Y(), R.X(), R.Y(), + g.X(), g.Y(), alpha.X(), alpha.Y(), + ) + if challenge.Cmp(vectorInt(t, fixture.ZKV.LegacyChallenge)) != 0 { + t.Fatalf("historical ZKV challenge = %x, want %s", challenge, fixture.ZKV.LegacyChallenge) + } + if !proof.Verify(V, R) { + t.Fatal("PRIOR-generated ZKV fixture did not verify with the R1 legacy API") + } + + for i := 0; i < 20; i++ { + generated, err := schnorr.NewZKVProof(V, R, s, l) + if err != nil { + t.Fatal(err) + } + if !historicalVerifyZKV(generated, V, R) { + t.Fatalf("R1 legacy ZKV proof %d did not verify with the historical formula", i) + } + } +} + +func historicalVerifyZKV( + proof *schnorr.ZKVProof, + V, R *crypto.ECPoint, +) bool { + ec := V.Curve() + q := ec.Params().N + g := crypto.NewECPointNoCurveCheck(ec, ec.Params().Gx, ec.Params().Gy) + c := common.HashToN( + q, + V.X(), V.Y(), R.X(), R.Y(), + g.X(), g.Y(), proof.Alpha.X(), proof.Alpha.Y(), + ) + tR := R.ScalarMult(proof.T) + uG := crypto.ScalarBaseMult(ec, proof.U) + left, err := tR.Add(uG) + if err != nil { + return false + } + Vc := V.ScalarMult(c) + right, err := proof.Alpha.Add(Vc) + return err == nil && left.Equals(right) +} + +// TestSecurityV2SchnorrVectorsFailClosed pins session/domain/input mutation, +// empty-session rejection, and legacy/security-v2 cross-mode rejection for +// both proof systems. +func TestSecurityV2SchnorrVectorsFailClosed(t *testing.T) { + fixture := loadLegacyTranscriptVectors(t) + session, err := hex.DecodeString(fixture.SecurityV2Session) + if err != nil { + t.Fatal(err) + } + ec := tss.EC() + q := ec.Params().N + g := crypto.NewECPointNoCurveCheck(ec, ec.Params().Gx, ec.Params().Gy) + + x := vectorInt(t, fixture.ZK.PrivateScalar) + a := vectorInt(t, fixture.ZK.Nonce) + X := pointFromVector(t, fixture.ZK.PublicPoint) + alpha := pointFromVector(t, fixture.ZK.SecurityV2Proof.Alpha) + securityZK := &schnorr.ZKProof{ + Alpha: alpha, + T: vectorInt(t, fixture.ZK.SecurityV2Proof.T), + } + legacyZK := &schnorr.ZKProof{ + Alpha: alpha, + T: vectorInt(t, fixture.ZK.LegacyProof.T), + } + zkChallenge := taggedChallenge( + zkDomain, + session, + X.X(), X.Y(), g.X(), g.Y(), alpha.X(), alpha.Y(), + ) + if zkChallenge.Cmp(vectorInt(t, fixture.ZK.SecurityV2Challenge)) != 0 { + t.Fatalf("security-v2 ZK challenge = %x, want %s", zkChallenge, fixture.ZK.SecurityV2Challenge) + } + if !securityZK.VerifyWithSession(session, X) { + t.Fatal("security-v2 ZK fixture did not verify") + } + if securityZK.Verify(X) || legacyZK.VerifyWithSession(session, X) { + t.Fatal("ZK proof crossed the legacy/security-v2 mode boundary") + } + if _, err := schnorr.NewZKProofWithSession(nil, x, X); err == nil { + t.Fatal("nil ZK session was accepted") + } + if _, err := schnorr.NewZKProofWithSession([]byte{}, x, X); err == nil { + t.Fatal("non-nil empty ZK session was accepted") + } + if securityZK.VerifyWithSession(nil, X) || securityZK.VerifyWithSession([]byte{}, X) { + t.Fatal("ZK verifier accepted an empty session") + } + mutatedSession := append([]byte(nil), session...) + mutatedSession[0] ^= 0x01 + if securityZK.VerifyWithSession(mutatedSession, X) { + t.Fatal("ZK verifier accepted a mutated session") + } + mutatedX := crypto.ScalarBaseMult(ec, new(big.Int).Add(x, big.NewInt(1))) + if securityZK.VerifyWithSession(session, mutatedX) { + t.Fatal("ZK verifier accepted a mutated public input") + } + wrongDomainChallenge := taggedChallenge( + zkvDomain, + session, + X.X(), X.Y(), g.X(), g.Y(), alpha.X(), alpha.Y(), + ) + wrongDomainProof := &schnorr.ZKProof{ + Alpha: alpha, + T: common.ModInt(q).Add( + a, + new(big.Int).Mul(wrongDomainChallenge, x), + ), + } + if wrongDomainProof.VerifyWithSession(session, X) { + t.Fatal("ZK verifier accepted a proof from the ZKV domain") + } + + R := pointFromVector(t, fixture.ZKV.R) + V := pointFromVector(t, fixture.ZKV.V) + s := vectorInt(t, fixture.ZKV.S) + l := vectorInt(t, fixture.ZKV.L) + va := vectorInt(t, fixture.ZKV.NonceA) + vb := vectorInt(t, fixture.ZKV.NonceB) + vAlpha := pointFromVector(t, fixture.ZKV.SecurityV2Proof.Alpha) + securityZKV := &schnorr.ZKVProof{ + Alpha: vAlpha, + T: vectorInt(t, fixture.ZKV.SecurityV2Proof.T), + U: vectorInt(t, fixture.ZKV.SecurityV2Proof.U), + } + legacyZKV := &schnorr.ZKVProof{ + Alpha: vAlpha, + T: vectorInt(t, fixture.ZKV.LegacyProof.T), + U: vectorInt(t, fixture.ZKV.LegacyProof.U), + } + zkvChallenge := taggedChallenge( + zkvDomain, + session, + V.X(), V.Y(), R.X(), R.Y(), + g.X(), g.Y(), vAlpha.X(), vAlpha.Y(), + ) + if zkvChallenge.Cmp(vectorInt(t, fixture.ZKV.SecurityV2Challenge)) != 0 { + t.Fatalf("security-v2 ZKV challenge = %x, want %s", zkvChallenge, fixture.ZKV.SecurityV2Challenge) + } + if !securityZKV.VerifyWithSession(session, V, R) { + t.Fatal("security-v2 ZKV fixture did not verify") + } + if securityZKV.Verify(V, R) || legacyZKV.VerifyWithSession(session, V, R) { + t.Fatal("ZKV proof crossed the legacy/security-v2 mode boundary") + } + if _, err := schnorr.NewZKVProofWithSession(nil, V, R, s, l); err == nil { + t.Fatal("nil ZKV session was accepted") + } + if _, err := schnorr.NewZKVProofWithSession([]byte{}, V, R, s, l); err == nil { + t.Fatal("non-nil empty ZKV session was accepted") + } + if securityZKV.VerifyWithSession(nil, V, R) || + securityZKV.VerifyWithSession([]byte{}, V, R) { + t.Fatal("ZKV verifier accepted an empty session") + } + if securityZKV.VerifyWithSession(mutatedSession, V, R) { + t.Fatal("ZKV verifier accepted a mutated session") + } + mutatedV := crypto.ScalarBaseMult(ec, new(big.Int).Add(s, l)) + if securityZKV.VerifyWithSession(session, mutatedV, R) { + t.Fatal("ZKV verifier accepted a mutated public input") + } + wrongZKVDomainChallenge := taggedChallenge( + zkDomain, + session, + V.X(), V.Y(), R.X(), R.Y(), + g.X(), g.Y(), vAlpha.X(), vAlpha.Y(), + ) + wrongDomainZKV := &schnorr.ZKVProof{ + Alpha: vAlpha, + T: common.ModInt(q).Add( + va, + new(big.Int).Mul(wrongZKVDomainChallenge, s), + ), + U: common.ModInt(q).Add( + vb, + new(big.Int).Mul(wrongZKVDomainChallenge, l), + ), + } + if wrongDomainZKV.VerifyWithSession(session, V, R) { + t.Fatal("ZKV verifier accepted a proof from the ZK domain") + } +} + +// TestLegacySchnorrWireVectors pins the exact protobuf payload carrying the +// fixed PRIOR-compatible proofs through signing rounds 4 and 6. This catches a +// proof that cross-verifies mathematically but drifts on serialization. +func TestLegacySchnorrWireVectors(t *testing.T) { + fixture := loadLegacyTranscriptVectors(t) + party := tss.NewPartyID("r01-vector", "r01-vector", big.NewInt(42)) + zkProof := &schnorr.ZKProof{ + Alpha: pointFromVector(t, fixture.ZK.LegacyProof.Alpha), + T: vectorInt(t, fixture.ZK.LegacyProof.T), + } + zkvProof := &schnorr.ZKVProof{ + Alpha: pointFromVector(t, fixture.ZKV.LegacyProof.Alpha), + T: vectorInt(t, fixture.ZKV.LegacyProof.T), + U: vectorInt(t, fixture.ZKV.LegacyProof.U), + } + + round4 := signing.NewSignRound4Message( + party, + commitments.HashDeCommitment{big.NewInt(11), big.NewInt(12), big.NewInt(13)}, + zkProof, + ) + assertWireHex(t, round4, fixture.ZK.LegacyRound4Wire) + + round6 := signing.NewSignRound6Message( + party, + commitments.HashDeCommitment{ + big.NewInt(21), big.NewInt(22), big.NewInt(23), big.NewInt(24), big.NewInt(25), + }, + zkProof, + zkvProof, + ) + assertWireHex(t, round6, fixture.ZKV.LegacyRound6Wire) +} + +func assertWireHex(t *testing.T, message tss.ParsedMessage, expected string) { + t.Helper() + encoded, _, err := message.WireBytes() + if err != nil { + t.Fatal(err) + } + if got := hex.EncodeToString(encoded); got != expected { + t.Fatalf("wire bytes differ\ngot: %s\nwant: %s", got, expected) + } +} + +func TestLegacyVectorChecksumSidecar(t *testing.T) { + raw, err := os.ReadFile(legacyVectorPath + ".sha256") + if err != nil { + t.Fatal(err) + } + want := fmt.Sprintf("%s legacy_transcript_vectors.json\n", legacyVectorSHA256) + if string(raw) != want { + t.Fatalf("checksum sidecar = %q, want %q", raw, want) + } +} diff --git a/crypto/schnorr/schnorr_proof.go b/crypto/schnorr/schnorr_proof.go index c85b6400..545c641b 100644 --- a/crypto/schnorr/schnorr_proof.go +++ b/crypto/schnorr/schnorr_proof.go @@ -39,14 +39,45 @@ func fsSessionZKV(session []byte) []byte { return append([]byte(fsDomainTagZKV+"|"), session...) } -// NewZKProof constructs a new Schnorr ZK proof of knowledge of the discrete logarithm (GG18Spec Fig. 16) +// NewZKProof constructs a legacy Schnorr ZK proof of knowledge of the discrete +// logarithm (GG18Spec Fig. 16). +// +// Legacy is an exact transcript contract, not merely the absence of a session: +// the challenge is HashToN(q, Xx, Xy, Gx, Gy, AlphaX, AlphaY), in that order, +// matching threshold-network/tss-lib@2e712689cfbe. New protocols should call +// NewZKProofWithSession with a non-empty, ceremony-unique session instead. func NewZKProof(x *big.Int, X *crypto.ECPoint) (*ZKProof, error) { - return NewZKProofWithSession(nil, x, X) + return newZKProof(x, X, legacyZKChallenge) } -// NewZKProofWithSession constructs a Schnorr proof with the session bound into -// the Fiat-Shamir challenge. +// NewZKProofWithSession constructs a security-v2 Schnorr proof with a non-empty +// session and the ZK domain tag bound into the Fiat-Shamir challenge. A nil or +// empty session is rejected; callers selecting the historical transcript must +// use NewZKProof, so this API can never silently downgrade to legacy. func NewZKProofWithSession(session []byte, x *big.Int, X *crypto.ECPoint) (*ZKProof, error) { + if len(session) == 0 { + return nil, errors.New("schnorr: ZK proof session tag must be non-empty") + } + + return newZKProof( + x, + X, + func(q *big.Int, X, g, alpha *crypto.ECPoint) *big.Int { + return sessionBoundZKChallenge(session, q, X, g, alpha) + }, + ) +} + +type zkChallenge func( + q *big.Int, + X, g, alpha *crypto.ECPoint, +) *big.Int + +func newZKProof( + x *big.Int, + X *crypto.ECPoint, + challenge zkChallenge, +) (*ZKProof, error) { if x == nil || X == nil || !X.ValidateBasic() { return nil, errors.New("ZKProof constructor received nil or invalid value(s)") } @@ -58,22 +89,67 @@ func NewZKProofWithSession(session []byte, x *big.Int, X *crypto.ECPoint) (*ZKPr a := common.GetRandomPositiveInt(q) alpha := crypto.ScalarBaseMult(ec, a) - cHash := common.SHA512_256i_TAGGED(fsSessionZK(session), X.X(), X.Y(), g.X(), g.Y(), alpha.X(), alpha.Y()) - c := common.ModReduceHash(q, cHash) + c := challenge(q, X, g, alpha) t := new(big.Int).Mul(c, x) t = common.ModInt(q).Add(a, t) return &ZKProof{Alpha: alpha, T: t}, nil } -// NewZKProof verifies a new Schnorr ZK proof of knowledge of the discrete logarithm (GG18Spec Fig. 16) +// legacyZKChallenge reproduces the historical HashToN input sequence and its +// expand-then-reduce behavior exactly. Keep it separate from the tagged path: +// treating a nil session as a tag would change legacy proof bytes. +func legacyZKChallenge( + q *big.Int, + X, g, alpha *crypto.ECPoint, +) *big.Int { + return common.HashToN( + q, + X.X(), X.Y(), + g.X(), g.Y(), + alpha.X(), alpha.Y(), + ) +} + +// sessionBoundZKChallenge derives the security-v2 ZK challenge. Its callers +// validate that session is non-empty before reaching this function. +func sessionBoundZKChallenge( + session []byte, + q *big.Int, + X, g, alpha *crypto.ECPoint, +) *big.Int { + cHash := common.SHA512_256i_TAGGED( + fsSessionZK(session), + X.X(), X.Y(), + g.X(), g.Y(), + alpha.X(), alpha.Y(), + ) + return common.ModReduceHash(q, cHash) +} + +// Verify verifies a ZK proof against the exact historical legacy challenge. +// Session-bound proofs must be verified with VerifyWithSession. func (pf *ZKProof) Verify(X *crypto.ECPoint) bool { - return pf.VerifyWithSession(nil, X) + return pf.verify(X, legacyZKChallenge) } -// VerifyWithSession verifies a Schnorr proof with the session bound into the -// Fiat-Shamir challenge. +// VerifyWithSession verifies a security-v2 Schnorr proof with a non-empty +// session bound into the challenge. Nil and empty sessions fail closed; use +// Verify for the historical transcript. func (pf *ZKProof) VerifyWithSession(session []byte, X *crypto.ECPoint) bool { + if len(session) == 0 { + return false + } + + return pf.verify( + X, + func(q *big.Int, X, g, alpha *crypto.ECPoint) *big.Int { + return sessionBoundZKChallenge(session, q, X, g, alpha) + }, + ) +} + +func (pf *ZKProof) verify(X *crypto.ECPoint, challenge zkChallenge) bool { if pf == nil || !pf.ValidateBasic() || X == nil || !X.ValidateBasic() { return false } @@ -88,8 +164,7 @@ func (pf *ZKProof) VerifyWithSession(session []byte, X *crypto.ECPoint) bool { } g := crypto.NewECPointNoCurveCheck(ec, ecParams.Gx, ecParams.Gy) - cHash := common.SHA512_256i_TAGGED(fsSessionZK(session), X.X(), X.Y(), g.X(), g.Y(), pf.Alpha.X(), pf.Alpha.Y()) - c := common.ModReduceHash(q, cHash) + c := challenge(q, X, g, pf.Alpha) if c.Sign() == 0 { return false } @@ -110,17 +185,51 @@ func (pf *ZKProof) ValidateBasic() bool { return pf.T != nil && pf.Alpha != nil && pf.Alpha.ValidateBasic() } -// NewZKProof constructs a new Schnorr ZK proof of knowledge s_i, l_i such that V_i = R^s_i, g^l_i (GG18Spec Fig. 17) +// NewZKVProof constructs a legacy Schnorr proof of knowledge of s_i and l_i +// such that V_i = R^s_i g^l_i (GG18Spec Fig. 17). +// +// Its challenge is exactly HashToN(q, Vx, Vy, Rx, Ry, Gx, Gy, AlphaX, +// AlphaY), matching threshold-network/tss-lib@2e712689cfbe. New protocols +// should call NewZKVProofWithSession instead. func NewZKVProof(V, R *crypto.ECPoint, s, l *big.Int) (*ZKVProof, error) { - return NewZKVProofWithSession(nil, V, R, s, l) + return newZKVProof(V, R, s, l, legacyZKVChallenge) } -// NewZKVProofWithSession constructs a Schnorr V proof with the session bound -// into the Fiat-Shamir challenge. +// NewZKVProofWithSession constructs a security-v2 Schnorr V proof with a +// non-empty session and the ZKV domain tag bound into the challenge. A nil or +// empty session is rejected; use NewZKVProof for the historical transcript. func NewZKVProofWithSession(session []byte, V, R *crypto.ECPoint, s, l *big.Int) (*ZKVProof, error) { + if len(session) == 0 { + return nil, errors.New("schnorr: ZKV proof session tag must be non-empty") + } + + return newZKVProof( + V, + R, + s, + l, + func(q *big.Int, V, R, g, alpha *crypto.ECPoint) *big.Int { + return sessionBoundZKVChallenge(session, q, V, R, g, alpha) + }, + ) +} + +type zkvChallenge func( + q *big.Int, + V, R, g, alpha *crypto.ECPoint, +) *big.Int + +func newZKVProof( + V, R *crypto.ECPoint, + s, l *big.Int, + challenge zkvChallenge, +) (*ZKVProof, error) { if V == nil || R == nil || s == nil || l == nil || !V.ValidateBasic() || !R.ValidateBasic() { return nil, errors.New("ZKVProof constructor received nil value(s)") } + if !crypto.SameCurve(V.Curve(), R.Curve()) { + return nil, errors.New("ZKVProof constructor received points on different curves") + } ec := V.Curve() ecParams := ec.Params() q := ecParams.N @@ -131,8 +240,7 @@ func NewZKVProofWithSession(session []byte, V, R *crypto.ECPoint, s, l *big.Int) bG := crypto.ScalarBaseMult(ec, b) alpha, _ := aR.Add(bG) // already on the curve. - cHash := common.SHA512_256i_TAGGED(fsSessionZKV(session), V.X(), V.Y(), R.X(), R.Y(), g.X(), g.Y(), alpha.X(), alpha.Y()) - c := common.ModReduceHash(q, cHash) + c := challenge(q, V, R, g, alpha) modQ := common.ModInt(q) t := modQ.Add(a, new(big.Int).Mul(c, s)) @@ -141,13 +249,65 @@ func NewZKVProofWithSession(session []byte, V, R *crypto.ECPoint, s, l *big.Int) return &ZKVProof{Alpha: alpha, T: t, U: u}, nil } +// legacyZKVChallenge reproduces the historical HashToN input sequence and +// modular reduction exactly. +func legacyZKVChallenge( + q *big.Int, + V, R, g, alpha *crypto.ECPoint, +) *big.Int { + return common.HashToN( + q, + V.X(), V.Y(), + R.X(), R.Y(), + g.X(), g.Y(), + alpha.X(), alpha.Y(), + ) +} + +// sessionBoundZKVChallenge derives the security-v2 ZKV challenge. Its callers +// validate that session is non-empty before reaching this function. +func sessionBoundZKVChallenge( + session []byte, + q *big.Int, + V, R, g, alpha *crypto.ECPoint, +) *big.Int { + cHash := common.SHA512_256i_TAGGED( + fsSessionZKV(session), + V.X(), V.Y(), + R.X(), R.Y(), + g.X(), g.Y(), + alpha.X(), alpha.Y(), + ) + return common.ModReduceHash(q, cHash) +} + +// Verify verifies a ZKV proof against the exact historical legacy challenge. +// Session-bound proofs must be verified with VerifyWithSession. func (pf *ZKVProof) Verify(V, R *crypto.ECPoint) bool { - return pf.VerifyWithSession(nil, V, R) + return pf.verify(V, R, legacyZKVChallenge) } -// VerifyWithSession verifies a Schnorr V proof with the session bound into the -// Fiat-Shamir challenge. +// VerifyWithSession verifies a security-v2 Schnorr V proof with a non-empty +// session bound into the challenge. Nil and empty sessions fail closed; use +// Verify for the historical transcript. func (pf *ZKVProof) VerifyWithSession(session []byte, V, R *crypto.ECPoint) bool { + if len(session) == 0 { + return false + } + + return pf.verify( + V, + R, + func(q *big.Int, V, R, g, alpha *crypto.ECPoint) *big.Int { + return sessionBoundZKVChallenge(session, q, V, R, g, alpha) + }, + ) +} + +func (pf *ZKVProof) verify( + V, R *crypto.ECPoint, + challenge zkvChallenge, +) bool { if pf == nil || !pf.ValidateBasic() || V == nil || R == nil || !V.ValidateBasic() || !R.ValidateBasic() { return false @@ -163,8 +323,7 @@ func (pf *ZKVProof) VerifyWithSession(session []byte, V, R *crypto.ECPoint) bool } g := crypto.NewECPointNoCurveCheck(ec, ecParams.Gx, ecParams.Gy) - cHash := common.SHA512_256i_TAGGED(fsSessionZKV(session), V.X(), V.Y(), R.X(), R.Y(), g.X(), g.Y(), pf.Alpha.X(), pf.Alpha.Y()) - c := common.ModReduceHash(q, cHash) + c := challenge(q, V, R, g, pf.Alpha) if c.Sign() == 0 { return false } diff --git a/crypto/schnorr/testdata/generate/main.go b/crypto/schnorr/testdata/generate/main.go new file mode 100644 index 00000000..5f7b526c --- /dev/null +++ b/crypto/schnorr/testdata/generate/main.go @@ -0,0 +1,236 @@ +//go:build ignore + +// Command generate emits the checked-in Schnorr transcript vectors in the +// parent testdata directory. It deliberately derives challenges from the +// documented formulas instead of calling schnorr's private challenge helpers, +// so the fixture remains an independent oracle for those helpers. +// +// Run from the module root with: +// +// go run ./crypto/schnorr/testdata/generate/main.go > /tmp/schnorr-vectors.json +// +// Compare the output with ../legacy_transcript_vectors.json and update that +// file only when the historical or security-v2 transcript contract changes +// intentionally. The fixed private values below are test material only. +package main + +import ( + "encoding/hex" + "encoding/json" + "fmt" + "math/big" + + "github.com/bnb-chain/tss-lib/common" + "github.com/bnb-chain/tss-lib/crypto" + "github.com/bnb-chain/tss-lib/crypto/commitments" + "github.com/bnb-chain/tss-lib/crypto/schnorr" + "github.com/bnb-chain/tss-lib/ecdsa/signing" + "github.com/bnb-chain/tss-lib/tss" +) + +const ( + zkDomain = "tss-lib.threshold.schnorr.zk|" + zkvDomain = "tss-lib.threshold.schnorr.zkv|" +) + +type point struct { + X string `json:"x"` + Y string `json:"y"` +} + +type proof struct { + Alpha point `json:"alpha"` + T string `json:"t"` + U string `json:"u,omitempty"` +} + +type zkVector struct { + PrivateScalar string `json:"private_scalar"` + Nonce string `json:"nonce"` + PublicPoint point `json:"public_point"` + LegacyChallenge string `json:"legacy_challenge"` + LegacyProof proof `json:"legacy_proof"` + SecurityV2Challenge string `json:"security_v2_challenge"` + SecurityV2Proof proof `json:"security_v2_proof"` + LegacyRound4Wire string `json:"legacy_round4_wire"` +} + +type zkvVector struct { + RScalar string `json:"r_scalar"` + S string `json:"s"` + L string `json:"l"` + NonceA string `json:"nonce_a"` + NonceB string `json:"nonce_b"` + R point `json:"r"` + V point `json:"v"` + LegacyChallenge string `json:"legacy_challenge"` + LegacyProof proof `json:"legacy_proof"` + SecurityV2Challenge string `json:"security_v2_challenge"` + SecurityV2Proof proof `json:"security_v2_proof"` + LegacyRound6Wire string `json:"legacy_round6_wire"` +} + +type vectors struct { + SchemaVersion int `json:"schema_version"` + Provenance struct { + HistoricalModule string `json:"historical_module"` + HistoricalSchnorrSourceSHA256 string `json:"historical_schnorr_source_sha256"` + RegressionBase string `json:"regression_base"` + RegressionSourceSHA256 string `json:"regression_source_sha256"` + Curve string `json:"curve"` + Encoding string `json:"encoding"` + } `json:"provenance"` + Session string `json:"security_v2_session"` + ZK zkVector `json:"zk"` + ZKV zkvVector `json:"zkv"` +} + +func mustHex(value string) *big.Int { + result, ok := new(big.Int).SetString(value, 16) + if !ok { + panic("invalid fixture integer: " + value) + } + return result +} + +func hexInt(value *big.Int) string { + return fmt.Sprintf("%064x", value) +} + +func vectorPoint(value *crypto.ECPoint) point { + return point{X: hexInt(value.X()), Y: hexInt(value.Y())} +} + +func taggedChallenge(tag string, session []byte, q *big.Int, values ...*big.Int) *big.Int { + domain := append([]byte(tag), session...) + return common.ModReduceHash(q, common.SHA512_256i_TAGGED(domain, values...)) +} + +func wireHex(message tss.ParsedMessage) string { + encoded, _, err := message.WireBytes() + if err != nil { + panic(err) + } + return hex.EncodeToString(encoded) +} + +func main() { + ec := tss.EC() + q := ec.Params().N + g := crypto.NewECPointNoCurveCheck(ec, ec.Params().Gx, ec.Params().Gy) + session := []byte("R01/security-v2/schnorr/vector/01") + + x := mustHex("1dce8d2ec6184cca4af42b3a1f62f4fe7b6dc5455c9f95e4d92cfdc2f2497a1") + a := mustHex("5a17c9e1b4d27f86a529134976cab0d3ed21f6634bd64a4789c25f3aeb80122") + X := crypto.ScalarBaseMult(ec, x) + alpha := crypto.ScalarBaseMult(ec, a) + legacyZKChallenge := common.HashToN( + q, + X.X(), X.Y(), g.X(), g.Y(), alpha.X(), alpha.Y(), + ) + securityZKChallenge := taggedChallenge( + zkDomain, + session, + q, + X.X(), X.Y(), g.X(), g.Y(), alpha.X(), alpha.Y(), + ) + legacyZKT := common.ModInt(q).Add(a, new(big.Int).Mul(legacyZKChallenge, x)) + securityZKT := common.ModInt(q).Add(a, new(big.Int).Mul(securityZKChallenge, x)) + legacyZKProof := &schnorr.ZKProof{Alpha: alpha, T: legacyZKT} + + rScalar := mustHex("3c4f5a6b7c8d9eaf102132435465768798a9bacbdcedfe0f1122334455667788") + s := mustHex("21765a43f18ce04277b894abcdeffedcba49876543210123456789abcdef0123") + l := mustHex("6e2c4b8a0d13579b2468ace02468ace13579bdf1029384756aabbccddeeff001") + va := mustHex("4a4b4c4d4e4f50515253545556575859606162636465666768696a6b6c6d6e6f") + vb := mustHex("7f6e5d4c3b2a190817263544536271809faebdccdbeaf9081726354453627180") + R := crypto.ScalarBaseMult(ec, rScalar) + sR := R.ScalarMult(s) + lG := crypto.ScalarBaseMult(ec, l) + V, err := sR.Add(lG) + if err != nil { + panic(err) + } + aR := R.ScalarMult(va) + bG := crypto.ScalarBaseMult(ec, vb) + vAlpha, err := aR.Add(bG) + if err != nil { + panic(err) + } + legacyZKVChallenge := common.HashToN( + q, + V.X(), V.Y(), R.X(), R.Y(), g.X(), g.Y(), vAlpha.X(), vAlpha.Y(), + ) + securityZKVChallenge := taggedChallenge( + zkvDomain, + session, + q, + V.X(), V.Y(), R.X(), R.Y(), g.X(), g.Y(), vAlpha.X(), vAlpha.Y(), + ) + legacyZKVT := common.ModInt(q).Add(va, new(big.Int).Mul(legacyZKVChallenge, s)) + legacyZKVU := common.ModInt(q).Add(vb, new(big.Int).Mul(legacyZKVChallenge, l)) + securityZKVT := common.ModInt(q).Add(va, new(big.Int).Mul(securityZKVChallenge, s)) + securityZKVU := common.ModInt(q).Add(vb, new(big.Int).Mul(securityZKVChallenge, l)) + legacyZKVProof := &schnorr.ZKVProof{Alpha: vAlpha, T: legacyZKVT, U: legacyZKVU} + + party := tss.NewPartyID("r01-vector", "r01-vector", big.NewInt(42)) + round4 := signing.NewSignRound4Message( + party, + commitments.HashDeCommitment{big.NewInt(11), big.NewInt(12), big.NewInt(13)}, + legacyZKProof, + ) + round6 := signing.NewSignRound6Message( + party, + commitments.HashDeCommitment{ + big.NewInt(21), big.NewInt(22), big.NewInt(23), big.NewInt(24), big.NewInt(25), + }, + legacyZKProof, + legacyZKVProof, + ) + + fixture := vectors{SchemaVersion: 1, Session: hex.EncodeToString(session)} + fixture.Provenance.HistoricalModule = "github.com/threshold-network/tss-lib@2e712689cfbeefede15f95a0ec7112227d86f702" + fixture.Provenance.HistoricalSchnorrSourceSHA256 = "e96a7c9cacf18b684e1f88bc5e7c6673cd341c224ae460abe7dd77db88dd05aa" + fixture.Provenance.RegressionBase = "github.com/threshold-network/tss-lib@d847ce0030193ccf5dbec0097571dcce5a2a5cf6" + fixture.Provenance.RegressionSourceSHA256 = "0d1c6f095abf2e8ad8e393b7b00705f72ddd03eb1fb23aedbba1987857d2cf6d" + fixture.Provenance.Curve = "secp256k1" + fixture.Provenance.Encoding = "lowercase fixed-width 32-byte hexadecimal integers; deterministic protobuf Any wire bytes" + fixture.ZK = zkVector{ + PrivateScalar: hexInt(x), + Nonce: hexInt(a), + PublicPoint: vectorPoint(X), + LegacyChallenge: hexInt(legacyZKChallenge), + LegacyProof: proof{Alpha: vectorPoint(alpha), T: hexInt(legacyZKT)}, + SecurityV2Challenge: hexInt(securityZKChallenge), + SecurityV2Proof: proof{Alpha: vectorPoint(alpha), T: hexInt(securityZKT)}, + LegacyRound4Wire: wireHex(round4), + } + fixture.ZKV = zkvVector{ + RScalar: hexInt(rScalar), + S: hexInt(s), + L: hexInt(l), + NonceA: hexInt(va), + NonceB: hexInt(vb), + R: vectorPoint(R), + V: vectorPoint(V), + LegacyChallenge: hexInt(legacyZKVChallenge), + LegacyProof: proof{Alpha: vectorPoint(vAlpha), T: hexInt(legacyZKVT), U: hexInt(legacyZKVU)}, + SecurityV2Challenge: hexInt(securityZKVChallenge), + SecurityV2Proof: proof{Alpha: vectorPoint(vAlpha), T: hexInt(securityZKVT), U: hexInt(securityZKVU)}, + LegacyRound6Wire: wireHex(round6), + } + + encoder := json.NewEncoder(fmtWriter{}) + encoder.SetIndent("", " ") + encoder.SetEscapeHTML(false) + if err := encoder.Encode(fixture); err != nil { + panic(err) + } +} + +// fmtWriter keeps the generator free of filesystem writes: callers decide +// where its deterministic stdout belongs. +type fmtWriter struct{} + +func (fmtWriter) Write(value []byte) (int, error) { + return fmt.Print(string(value)) +} diff --git a/crypto/schnorr/testdata/legacy_transcript_vectors.json b/crypto/schnorr/testdata/legacy_transcript_vectors.json new file mode 100644 index 00000000..a2e42eb8 --- /dev/null +++ b/crypto/schnorr/testdata/legacy_transcript_vectors.json @@ -0,0 +1,71 @@ +{ + "schema_version": 1, + "provenance": { + "historical_module": "github.com/threshold-network/tss-lib@2e712689cfbeefede15f95a0ec7112227d86f702", + "historical_schnorr_source_sha256": "e96a7c9cacf18b684e1f88bc5e7c6673cd341c224ae460abe7dd77db88dd05aa", + "regression_base": "github.com/threshold-network/tss-lib@d847ce0030193ccf5dbec0097571dcce5a2a5cf6", + "regression_source_sha256": "0d1c6f095abf2e8ad8e393b7b00705f72ddd03eb1fb23aedbba1987857d2cf6d", + "curve": "secp256k1", + "encoding": "lowercase fixed-width 32-byte hexadecimal integers; deterministic protobuf Any wire bytes" + }, + "security_v2_session": "5230312f73656375726974792d76322f7363686e6f72722f766563746f722f3031", + "zk": { + "private_scalar": "01dce8d2ec6184cca4af42b3a1f62f4fe7b6dc5455c9f95e4d92cfdc2f2497a1", + "nonce": "05a17c9e1b4d27f86a529134976cab0d3ed21f6634bd64a4789c25f3aeb80122", + "public_point": { + "x": "5703188d47600b463315ca19733565401c6dee4d7447db9a1dd75b791b220478", + "y": "41e4de2b512cc7ce46ea56d4902bbd3ef78d300948aeee900a7c6f5c35adf5b3" + }, + "legacy_challenge": "556bf4796826c21836bfef73fceb38f682dbb0bfa02de08ee389ae6b960c6f00", + "legacy_proof": { + "alpha": { + "x": "bd70b31bc9bee1d2dffa190245256a25a5e64b452f186af64c73a429b3574e3b", + "y": "6f191fe7541a76216c5f57f4e83be1451992b3be7b2b51c512286fa8381cb536" + }, + "t": "f079d3478901f87958c63e05042f93f4ede4792904cea81f0532a1833f7832c0" + }, + "security_v2_challenge": "5a9b34373ed79acf2004d667a3b104555b9885f8439b63df9d3d0d6b49c6b6e3", + "security_v2_proof": { + "alpha": { + "x": "bd70b31bc9bee1d2dffa190245256a25a5e64b452f186af64c73a429b3574e3b", + "y": "6f191fe7541a76216c5f57f4e83be1451992b3be7b2b51c512286fa8381cb536" + }, + "t": "6ff99f9799bda9df06a79f22dc5069046ae62c7a76a24d1fda0e48f41789c463" + }, + "legacy_round4_wire": "0a42747970652e676f6f676c65617069732e636f6d2f62696e616e63652e7473736c69622e65636473612e7369676e696e672e5369676e526f756e64344d657373616765126f0a010b0a010c0a010d1220bd70b31bc9bee1d2dffa190245256a25a5e64b452f186af64c73a429b3574e3b1a206f191fe7541a76216c5f57f4e83be1451992b3be7b2b51c512286fa8381cb5362220f079d3478901f87958c63e05042f93f4ede4792904cea81f0532a1833f7832c0" + }, + "zkv": { + "r_scalar": "3c4f5a6b7c8d9eaf102132435465768798a9bacbdcedfe0f1122334455667788", + "s": "21765a43f18ce04277b894abcdeffedcba49876543210123456789abcdef0123", + "l": "6e2c4b8a0d13579b2468ace02468ace13579bdf1029384756aabbccddeeff001", + "nonce_a": "4a4b4c4d4e4f50515253545556575859606162636465666768696a6b6c6d6e6f", + "nonce_b": "7f6e5d4c3b2a190817263544536271809faebdccdbeaf9081726354453627180", + "r": { + "x": "7f5c7404508c33320f0e7cd1ea419a2e2e703aee21789a1bd28d5eb7fe8bf56a", + "y": "cc8d699161752aab3bf4c6602767534ee86e9b0882c2be13a56e96d1c22fd30b" + }, + "v": { + "x": "47cd671385e21d1753ca3ace7cfb94b0e32219a910228ce69d887b7f72278c23", + "y": "e82ba7942b9bf28be2f5cd5510fd2ce3cc29c73ed0fa4a4b82b6bcd56e8aa784" + }, + "legacy_challenge": "0ca9792da3832c444b25d1ee1f188c08a8cbf84ef6845b2b3e722a00ac2d2e28", + "legacy_proof": { + "alpha": { + "x": "cfd11fc30235070069e211ad31f0d080b40acdd755ce6ccf01d3e8811c1a57f9", + "y": "2d59c28ca9f9f132a9ea1e12718b82bb6069df17c966639e12576c31e6a6913a" + }, + "t": "d113aaaaf2867e33a3171f09b9e7a209114faed211c8cf21082d23ba267e2b36", + "u": "5e24347c27ec838610a527f6f9acf47428bd14dda212ad746e28e0186d17932d" + }, + "security_v2_challenge": "57480a975084a224f98edd578a19bafb6bf3b7a991bea2088215539a1bbfd4ca", + "security_v2_proof": { + "alpha": { + "x": "cfd11fc30235070069e211ad31f0d080b40acdd755ce6ccf01d3e8811c1a57f9", + "y": "2d59c28ca9f9f132a9ea1e12718b82bb6069df17c966639e12576c31e6a6913a" + }, + "t": "e7f24f661810c32f7756657a62d0fb83726f7ee42c5f8494bb9186afff4b9fe2", + "u": "031603073cde7b52b351803317b1ab9ee6c8b8594c2c9dccb7c59fa7a861d8c2" + }, + "legacy_round6_wire": "0a42747970652e676f6f676c65617069732e636f6d2f62696e616e63652e7473736c69622e65636473612e7369676e696e672e5369676e526f756e64364d65737361676512fd010a01150a01160a01170a01180a01191220bd70b31bc9bee1d2dffa190245256a25a5e64b452f186af64c73a429b3574e3b1a206f191fe7541a76216c5f57f4e83be1451992b3be7b2b51c512286fa8381cb5362220f079d3478901f87958c63e05042f93f4ede4792904cea81f0532a1833f7832c02a20cfd11fc30235070069e211ad31f0d080b40acdd755ce6ccf01d3e8811c1a57f932202d59c28ca9f9f132a9ea1e12718b82bb6069df17c966639e12576c31e6a6913a3a20d113aaaaf2867e33a3171f09b9e7a209114faed211c8cf21082d23ba267e2b3642205e24347c27ec838610a527f6f9acf47428bd14dda212ad746e28e0186d17932d" + } +} diff --git a/crypto/schnorr/testdata/legacy_transcript_vectors.json.sha256 b/crypto/schnorr/testdata/legacy_transcript_vectors.json.sha256 new file mode 100644 index 00000000..c7605cfe --- /dev/null +++ b/crypto/schnorr/testdata/legacy_transcript_vectors.json.sha256 @@ -0,0 +1 @@ +2dec0490c875396c8161b4b5c522f8f451d6a987174194e22f6883741f6acffb legacy_transcript_vectors.json diff --git a/ecdsa/keygen/local_party.go b/ecdsa/keygen/local_party.go index f20c5003..61bddb74 100644 --- a/ecdsa/keygen/local_party.go +++ b/ecdsa/keygen/local_party.go @@ -65,6 +65,11 @@ func NewLocalParty( end chan<- LocalPartySaveData, optionalPreParams ...LocalPreParams, ) tss.Party { + if params == nil { + panic("keygen.NewLocalParty requires parameters") + } + params.FreezeProtocolMode() + partyCount := params.PartyCount() data := NewLocalPartySaveData(partyCount) // when `optionalPreParams` is provided we'll use the pre-computed primes instead of generating them from scratch diff --git a/ecdsa/keygen/local_party_test.go b/ecdsa/keygen/local_party_test.go index 137edd4e..ce866853 100644 --- a/ecdsa/keygen/local_party_test.go +++ b/ecdsa/keygen/local_party_test.go @@ -49,6 +49,7 @@ func TestSSIDIncludesSessionNonce(t *testing.T) { func testKeygenSSID(pIDs tss.SortedPartyIDs, sessionID []byte) []byte { params := tss.NewParameters(tss.S256(), tss.NewPeerContext(pIDs), pIDs[0], len(pIDs), 1) + params.SetProtocolMode(tss.ProtocolModeSecurityV2) params.SetSessionNonceBytes(sessionID) round := &base{ @@ -62,6 +63,7 @@ func testKeygenSSID(pIDs tss.SortedPartyIDs, sessionID []byte) []byte { func TestStoreMessageRejectsContentDifferentReplay(t *testing.T) { pIDs := tss.GenerateTestPartyIDs(2) params := tss.NewParameters(tss.S256(), tss.NewPeerContext(pIDs), pIDs[0], len(pIDs), 1) + params.SetProtocolMode(tss.ProtocolModeLegacy) lp := NewLocalParty(params, nil, nil).(*LocalParty) msg1 := NewKGRound2Message2(pIDs[1], []*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}) @@ -86,6 +88,7 @@ func TestStoreMessageRejectsContentDifferentReplay(t *testing.T) { func TestStoreMessageAllowsSelfReplacement(t *testing.T) { pIDs := tss.GenerateTestPartyIDs(2) params := tss.NewParameters(tss.S256(), tss.NewPeerContext(pIDs), pIDs[0], len(pIDs), 1) + params.SetProtocolMode(tss.ProtocolModeLegacy) lp := NewLocalParty(params, nil, nil).(*LocalParty) msg1 := NewKGRound2Message2(pIDs[0], []*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}) @@ -116,6 +119,7 @@ func TestKeygen_Start_RequiresSessionNonce(t *testing.T) { pIDs := tss.GenerateTestPartyIDs(2) p2pCtx := tss.NewPeerContext(pIDs) params := tss.NewParameters(tss.S256(), p2pCtx, pIDs[0], len(pIDs), 1) + params.SetProtocolMode(tss.ProtocolModeSecurityV2) // Deliberately do NOT call params.SetSessionNonce — Start must fail closed. out := make(chan tss.Message, 1) @@ -142,6 +146,7 @@ func TestStartRound1Paillier(t *testing.T) { p2pCtx := tss.NewPeerContext(pIDs) threshold := 1 params := tss.NewParameters(tss.EC(), p2pCtx, pIDs[0], len(pIDs), threshold) + params.SetProtocolMode(tss.ProtocolModeSecurityV2) params.SetSessionNonce(big.NewInt(1)) fixtures, pIDs, err := LoadKeygenTestFixtures(testParticipants) @@ -183,6 +188,7 @@ func TestFinishAndSaveH1H2(t *testing.T) { p2pCtx := tss.NewPeerContext(pIDs) threshold := 1 params := tss.NewParameters(tss.EC(), p2pCtx, pIDs[0], len(pIDs), threshold) + params.SetProtocolMode(tss.ProtocolModeSecurityV2) params.SetSessionNonce(big.NewInt(2)) fixtures, pIDs, err := LoadKeygenTestFixtures(testParticipants) @@ -231,6 +237,7 @@ func TestBadMessageCulprits(t *testing.T) { pIDs := tss.GenerateTestPartyIDs(2) p2pCtx := tss.NewPeerContext(pIDs) params := tss.NewParameters(tss.S256(), p2pCtx, pIDs[0], len(pIDs), 1) + params.SetProtocolMode(tss.ProtocolModeSecurityV2) params.SetSessionNonce(big.NewInt(3)) fixtures, pIDs, err := LoadKeygenTestFixtures(testParticipants) @@ -267,6 +274,20 @@ func TestBadMessageCulprits(t *testing.T) { } func TestE2EConcurrentAndSaveFixtures(t *testing.T) { + for _, testCase := range []struct { + name string + mode tss.ProtocolMode + }{ + {"legacy", tss.ProtocolModeLegacy}, + {"security-v2", tss.ProtocolModeSecurityV2}, + } { + t.Run(testCase.name, func(t *testing.T) { + testE2EConcurrentAndSaveFixtures(t, testCase.mode) + }) + } +} + +func testE2EConcurrentAndSaveFixtures(t *testing.T, mode tss.ProtocolMode) { setUp("info") // tss.SetCurve(elliptic.P256()) @@ -294,7 +315,10 @@ func TestE2EConcurrentAndSaveFixtures(t *testing.T) { for i := 0; i < len(pIDs); i++ { var P *LocalParty params := tss.NewParameters(tss.S256(), p2pCtx, pIDs[i], len(pIDs), threshold) - params.SetSessionNonce(ceremonyNonce) + params.SetProtocolMode(mode) + if mode == tss.ProtocolModeSecurityV2 { + params.SetSessionNonce(ceremonyNonce) + } if i < len(fixtures) { P = NewLocalParty(params, outCh, endCh, fixtures[i].LocalPreParams).(*LocalParty) } else { diff --git a/ecdsa/keygen/round_1.go b/ecdsa/keygen/round_1.go index f6847628..e07d85e0 100644 --- a/ecdsa/keygen/round_1.go +++ b/ecdsa/keygen/round_1.go @@ -84,18 +84,17 @@ func (round *round1) Start() *tss.Error { round.save.NTildej[i] = preParams.NTildei round.save.H1j[i], round.save.H2j[i] = preParams.H1i, preParams.H2i - // Keygen fails closed if no SessionNonce is set. The previous zero - // fallback neutralised the SSID binding for any caller that forgot - // SetSessionNonce — two keygen ceremonies over otherwise identical - // committees would derive the same SSID, exposing proof transcripts - // to splicing between runs. - nonce := round.Params().SessionNonce() - if nonce == nil || nonce.Sign() <= 0 { - return round.WrapError(errors.New("keygen requires tss.Parameters.SetSessionNonce() before Start"), Pi) + if round.ProtocolMode() == tss.ProtocolModeSecurityV2 { + // Security-v2 fails closed if no SessionNonce is set. Legacy mode + // intentionally has no nonce and uses the historical untagged proof + // transcript. + nonce := round.Params().SessionNonce() + if nonce == nil || nonce.Sign() <= 0 { + return round.WrapError(errors.New("security-v2 keygen requires tss.Parameters.SetSessionNonce() before Start"), Pi) + } + round.temp.ssidNonce = new(big.Int).Set(nonce) + round.temp.ssid = round.getSSID() } - round.temp.ssidNonce = new(big.Int).Set(nonce) - round.temp.ssid = round.getSSID() - contextI := common.AppendUint64ToBytesSlice(round.temp.ssid, uint64(i)) // generate the dlnproofs for keygen h1i, h2i, alpha, beta, p, q, NTildei := @@ -106,10 +105,26 @@ func (round *round1) Start() *tss.Error { preParams.P, preParams.Q, preParams.NTildei - dlnProof1 := dlnproof.NewDLNProof(h1i, h2i, alpha, p, q, NTildei, round.temp.ssid) - dlnProof2 := dlnproof.NewDLNProof(h2i, h1i, beta, p, q, NTildei, round.temp.ssid) - - modProof := preParams.PaillierSK.ModProof(contextI) + dlnProof1 := dlnproof.NewDLNProof( + h1i, + h2i, + alpha, + p, + q, + NTildei, + round.proofSession()..., + ) + dlnProof2 := dlnproof.NewDLNProof( + h2i, + h1i, + beta, + p, + q, + NTildei, + round.proofSession()..., + ) + + modProof := preParams.PaillierSK.ModProof(round.proofContext(i)...) // NTildei = (2p+1) * (2q+1) // phi(NTildei) = ((2p+1) - 1) * ((2q+1) - 1) = 2p * 2q @@ -122,7 +137,7 @@ func (round *round1) Start() *tss.Error { pkTilde := &paillier.PublicKey{N: NTildei} skTilde := &paillier.PrivateKey{PublicKey: *pkTilde, LambdaN: lambdaNTilde, PhiN: phiNTilde} - modProofTilde := skTilde.ModProof(contextI) + modProofTilde := skTilde.ModProof(round.proofContext(i)...) // for this P: SAVE // - shareID diff --git a/ecdsa/keygen/round_2.go b/ecdsa/keygen/round_2.go index ab13831d..8d0c4a92 100644 --- a/ecdsa/keygen/round_2.go +++ b/ecdsa/keygen/round_2.go @@ -71,32 +71,30 @@ func (round *round2) Start() *tss.Error { wg.Add(4) _j := j _msg := msg - contextJ := common.AppendUint64ToBytesSlice(round.temp.ssid, uint64(j)) - verifier.VerifyDLNProof1(r1msg, H1j, H2j, NTildej, func(isValid bool) { if !isValid { dlnProof1FailCulprits[_j] = _msg.GetFrom() } wg.Done() - }, round.temp.ssid) + }, round.proofSession()...) verifier.VerifyDLNProof2(r1msg, H2j, H1j, NTildej, func(isValid bool) { if !isValid { dlnProof2FailCulprits[_j] = _msg.GetFrom() } wg.Done() - }, round.temp.ssid) + }, round.proofSession()...) verifier.VerifyModProof(r1msg, paillierPKj.N, func(isValid bool) { if !isValid { modProofFailCulprits[_j] = _msg.GetFrom() } wg.Done() - }, contextJ) + }, round.proofContext(j)...) verifier.VerifyModProofTilde(r1msg, NTildej, func(isValid bool) { if !isValid { modProofTildeFailCulprits[_j] = _msg.GetFrom() } wg.Done() - }, contextJ) + }, round.proofContext(j)...) } wg.Wait() for _, culprit := range append(dlnProof1FailCulprits, dlnProof2FailCulprits...) { @@ -129,7 +127,6 @@ func (round *round2) Start() *tss.Error { // 5. p2p send share ij to Pj shares := round.temp.shares - contextI := common.AppendUint64ToBytesSlice(round.temp.ssid, uint64(i)) for j, Pj := range round.Parties().IDs() { // do not send to this Pj, but store for round 3 if j == i { @@ -137,8 +134,18 @@ func (round *round2) Start() *tss.Error { continue } H1j, H2j, NTildej := round.save.H1j[j], round.save.H2j[j], round.save.NTildej[j] - facProof := round.save.LocalPreParams.PaillierSK.FactorProof(NTildej, H1j, H2j, contextI) - facProofTilde := round.temp.skTilde.FactorProof(NTildej, H1j, H2j, contextI) + facProof := round.save.LocalPreParams.PaillierSK.FactorProof( + NTildej, + H1j, + H2j, + round.proofContext(i)..., + ) + facProofTilde := round.temp.skTilde.FactorProof( + NTildej, + H1j, + H2j, + round.proofContext(i)..., + ) r2msg1 := NewKGRound2Message1(Pj, round.PartyID(), shares[j], facProof, facProofTilde) round.out <- r2msg1 diff --git a/ecdsa/keygen/round_3.go b/ecdsa/keygen/round_3.go index 0134aeee..1658149b 100644 --- a/ecdsa/keygen/round_3.go +++ b/ecdsa/keygen/round_3.go @@ -65,7 +65,6 @@ func (round *round3) Start() *tss.Error { if j == PIdx { continue } - contextJ := common.AppendUint64ToBytesSlice(round.temp.ssid, uint64(j)) // 6-8. go func(j int, ch chan<- vssOut) { // 4-9. @@ -97,7 +96,13 @@ func (round *round3) Start() *tss.Error { pkN := round.save.PaillierPKs[j].N NTilde := round.save.LocalPreParams.NTildei H1i, H2i := round.save.LocalPreParams.H1i, round.save.LocalPreParams.H2i - ok, err = FacProof.FactorVerify(pkN, NTilde, H1i, H2i, contextJ) + ok, err = FacProof.FactorVerify( + pkN, + NTilde, + H1i, + H2i, + round.proofContext(j)..., + ) if err != nil { ch <- vssOut{err, nil} return @@ -108,7 +113,13 @@ func (round *round3) Start() *tss.Error { } FacProofTilde := r2msg1.UnmarshalFactorProofTilde() NTildej := round.save.NTildej[j] - ok, err = FacProofTilde.FactorVerify(NTildej, NTilde, H1i, H2i, contextJ) + ok, err = FacProofTilde.FactorVerify( + NTildej, + NTilde, + H1i, + H2i, + round.proofContext(j)..., + ) if err != nil { ch <- vssOut{err, nil} return diff --git a/ecdsa/keygen/rounds.go b/ecdsa/keygen/rounds.go index 85c0a24e..9474a210 100644 --- a/ecdsa/keygen/rounds.go +++ b/ecdsa/keygen/rounds.go @@ -98,6 +98,30 @@ func (round *base) resetOK() { } } +// proofSession returns the immutable per-party proof transcript selection in +// variadic-call form. Legacy parties deliberately pass no session so the +// proof primitives reproduce their historical challenges byte for byte. +func (round *base) proofSession() [][]byte { + if round.ProtocolMode() == tss.ProtocolModeSecurityV2 { + return [][]byte{round.temp.ssid} + } + return nil +} + +// proofContext extends the security-v2 session with the producing party's +// index. Legacy proofs predate these per-party transcript contexts. +func (round *base) proofContext(index int) [][]byte { + if round.ProtocolMode() == tss.ProtocolModeSecurityV2 { + return [][]byte{ + common.AppendUint64ToBytesSlice( + round.temp.ssid, + uint64(index), + ), + } + } + return nil +} + // getSSID derives the session-binding identifier for keygen. // // Callers must invoke this exactly once, in round 1, and store the result in diff --git a/ecdsa/signing/local_party.go b/ecdsa/signing/local_party.go index 8fafe9b4..34284f3a 100644 --- a/ecdsa/signing/local_party.go +++ b/ecdsa/signing/local_party.go @@ -127,6 +127,7 @@ func NewLocalPartyWithKDD( fullBytesLen ...int, ) tss.Party { validatedFullBytesLen := validateFullBytesLen("NewLocalPartyWithKDD", msg, params, fullBytesLen) + params.FreezeProtocolMode() partyCount := len(params.Parties().IDs()) p := &LocalParty{ diff --git a/ecdsa/signing/local_party_test.go b/ecdsa/signing/local_party_test.go index 6ecd0d91..4d73794e 100644 --- a/ecdsa/signing/local_party_test.go +++ b/ecdsa/signing/local_party_test.go @@ -79,6 +79,7 @@ func newStoreMessageTestParty(t *testing.T) (*LocalParty, tss.SortedPartyIDs) { pIDs := tss.GenerateTestPartyIDs(2) params := tss.NewParameters(tss.S256(), tss.NewPeerContext(pIDs), pIDs[0], len(pIDs), 1) + params.SetProtocolMode(tss.ProtocolModeLegacy) keys := keygen.NewLocalPartySaveData(len(pIDs)) for i, id := range pIDs { keys.Ks[i] = id.KeyInt() @@ -88,6 +89,20 @@ func newStoreMessageTestParty(t *testing.T) (*LocalParty, tss.SortedPartyIDs) { } func TestE2EConcurrent(t *testing.T) { + for _, testCase := range []struct { + name string + mode tss.ProtocolMode + }{ + {"legacy", tss.ProtocolModeLegacy}, + {"security-v2", tss.ProtocolModeSecurityV2}, + } { + t.Run(testCase.name, func(t *testing.T) { + testE2EConcurrent(t, testCase.mode) + }) + } +} + +func testE2EConcurrent(t *testing.T, mode tss.ProtocolMode) { setUp("info") threshold := testThreshold @@ -116,7 +131,10 @@ func TestE2EConcurrent(t *testing.T) { ceremonyNonce := big.NewInt(1) for i := 0; i < len(signPIDs); i++ { params := tss.NewParameters(tss.S256(), p2pCtx, signPIDs[i], len(signPIDs), threshold) - params.SetSessionNonce(ceremonyNonce) + params.SetProtocolMode(mode) + if mode == tss.ProtocolModeSecurityV2 { + params.SetSessionNonce(ceremonyNonce) + } P := NewLocalParty(msgInt, params, keys[i], outCh, endCh, len(msgData)).(*LocalParty) parties = append(parties, P) @@ -228,6 +246,7 @@ func TestE2EWithHDKeyDerivation(t *testing.T) { ceremonyNonce := big.NewInt(2) for i := 0; i < len(signPIDs); i++ { params := tss.NewParameters(tss.S256(), p2pCtx, signPIDs[i], len(signPIDs), threshold) + params.SetProtocolMode(tss.ProtocolModeSecurityV2) params.SetSessionNonce(ceremonyNonce) P := NewLocalPartyWithKDD(big.NewInt(42), params, keys[i], keyDerivationDelta, outCh, endCh, 32).(*LocalParty) @@ -316,6 +335,7 @@ func TestSigning_Start_RequiresSessionNonce(t *testing.T) { endCh := make(chan common.SignatureData, len(signPIDs)) params := tss.NewParameters(tss.S256(), p2pCtx, signPIDs[0], len(signPIDs), testThreshold) + params.SetProtocolMode(tss.ProtocolModeSecurityV2) // Deliberately do NOT call params.SetSessionNonce — Start must fail closed. P := NewLocalParty(big.NewInt(42), params, keys[0], outCh, endCh, 32).(*LocalParty) diff --git a/ecdsa/signing/round_1.go b/ecdsa/signing/round_1.go index 779d7da6..7f9e43a4 100644 --- a/ecdsa/signing/round_1.go +++ b/ecdsa/signing/round_1.go @@ -48,21 +48,21 @@ func (round *round1) Start() *tss.Error { round.number = 1 round.started = true round.resetOK() - // Signing fails closed if no SessionNonce is set. The previous fallback - // (SHA512_256 of the message) made two concurrent ceremonies on the same - // canonical message reuse the same SSID, which would have enabled - // Fiat-Shamir transcript splicing across the runs. The caller must now - // supply a per-ceremony nonce via tss.Parameters.SetSessionNonce. - nonce := round.Params().SessionNonce() - if nonce == nil || nonce.Sign() <= 0 { - return round.WrapError(errors.New("signing requires tss.Parameters.SetSessionNonce() before Start")) - } - round.temp.ssidNonce = new(big.Int).Set(nonce) - ssid, err := round.getSSID() - if err != nil { - return round.WrapError(err) + if round.ProtocolMode() == tss.ProtocolModeSecurityV2 { + // Security-v2 fails closed if no SessionNonce is set. Legacy mode + // intentionally has no nonce and uses the historical untagged proof + // transcript. + nonce := round.Params().SessionNonce() + if nonce == nil || nonce.Sign() <= 0 { + return round.WrapError(errors.New("security-v2 signing requires tss.Parameters.SetSessionNonce() before Start")) + } + round.temp.ssidNonce = new(big.Int).Set(nonce) + ssid, err := round.getSSID() + if err != nil { + return round.WrapError(err) + } + round.temp.ssid = ssid } - round.temp.ssid = ssid k := common.GetRandomPositiveInt(round.Params().EC().Params().N) gamma := common.GetRandomPositiveInt(round.Params().EC().Params().N) @@ -81,8 +81,15 @@ func (round *round1) Start() *tss.Error { if j == i { continue } - contextJ := common.AppendUint64ToBytesSlice(round.temp.ssid, uint64(j)) - cA, pi, err := mta.AliceInit(round.Params().EC(), round.key.PaillierPKs[i], k, round.key.NTildej[j], round.key.H1j[j], round.key.H2j[j], contextJ) + cA, pi, err := mta.AliceInit( + round.Params().EC(), + round.key.PaillierPKs[i], + k, + round.key.NTildej[j], + round.key.H1j[j], + round.key.H2j[j], + round.proofContext(j)..., + ) if err != nil { return round.WrapError(fmt.Errorf("failed to init mta: %v", err)) } diff --git a/ecdsa/signing/round_2.go b/ecdsa/signing/round_2.go index e63a7760..e32e6fc6 100644 --- a/ecdsa/signing/round_2.go +++ b/ecdsa/signing/round_2.go @@ -12,7 +12,6 @@ import ( errorspkg "github.com/pkg/errors" - "github.com/bnb-chain/tss-lib/common" "github.com/bnb-chain/tss-lib/crypto/mta" "github.com/bnb-chain/tss-lib/tss" ) @@ -31,7 +30,6 @@ func (round *round2) Start() *tss.Error { errChs := make(chan *tss.Error, (len(round.Parties().IDs())-1)*2) wg := sync.WaitGroup{} wg.Add((len(round.Parties().IDs()) - 1) * 2) - contextI := common.AppendUint64ToBytesSlice(round.temp.ssid, uint64(i)) attributeBobMidErr := func(err error, Pj *tss.PartyID) *tss.Error { if errors.Is(err, mta.ErrRangeProofVerify) { return round.WrapError(errorspkg.Wrap(err, "peer RangeProofAlice rejected"), Pj) @@ -63,7 +61,7 @@ func (round *round2) Start() *tss.Error { round.key.NTildej[i], round.key.H1j[i], round.key.H2j[i], - contextI) + round.proofContext(i)...) // should be thread safe as these are pre-allocated round.temp.betas[j] = beta round.temp.c1jis[j] = c1ji @@ -94,7 +92,7 @@ func (round *round2) Start() *tss.Error { round.key.H1j[i], round.key.H2j[i], round.temp.bigWs[i], - contextI) + round.proofContext(i)...) round.temp.vs[j] = v round.temp.c2jis[j] = c2ji round.temp.pi2jis[j] = pi2ji diff --git a/ecdsa/signing/round_3.go b/ecdsa/signing/round_3.go index 92dfc864..0c1be6c5 100644 --- a/ecdsa/signing/round_3.go +++ b/ecdsa/signing/round_3.go @@ -38,7 +38,6 @@ func (round *round3) Start() *tss.Error { if j == i { continue } - contextJ := common.AppendUint64ToBytesSlice(round.temp.ssid, uint64(j)) // Alice_end go func(j int, Pj *tss.PartyID) { defer wg.Done() @@ -58,7 +57,7 @@ func (round *round3) Start() *tss.Error { new(big.Int).SetBytes(r2msg.GetC1()), round.key.NTildej[i], round.key.PaillierSK, - contextJ) + round.proofContext(j)...) alphas[j] = alphaIj if err != nil { errChs <- round.WrapError(err, Pj) @@ -84,7 +83,7 @@ func (round *round3) Start() *tss.Error { round.key.H1j[i], round.key.H2j[i], round.key.PaillierSK, - contextJ) + round.proofContext(j)...) us[j] = uIj if err != nil { errChs <- round.WrapError(err, Pj) diff --git a/ecdsa/signing/round_4.go b/ecdsa/signing/round_4.go index b8b8467b..6c38442d 100644 --- a/ecdsa/signing/round_4.go +++ b/ecdsa/signing/round_4.go @@ -45,8 +45,20 @@ func (round *round4) Start() *tss.Error { return round.WrapError(errors.New("theta inverse is nil")) } i := round.PartyID().Index - contextI := common.AppendUint64ToBytesSlice(round.temp.ssid, uint64(i)) - piGamma, err := schnorr.NewZKProofWithSession(contextI, round.temp.gamma, round.temp.pointGamma) + var piGamma *schnorr.ZKProof + var err error + if round.ProtocolMode() == tss.ProtocolModeLegacy { + piGamma, err = schnorr.NewZKProof( + round.temp.gamma, + round.temp.pointGamma, + ) + } else { + piGamma, err = schnorr.NewZKProofWithSession( + round.proofContext(i)[0], + round.temp.gamma, + round.temp.pointGamma, + ) + } if err != nil { return round.WrapError(errors2.Wrapf(err, "NewZKProof(gamma, bigGamma)")) } diff --git a/ecdsa/signing/round_5.go b/ecdsa/signing/round_5.go index 963378b9..30d0b504 100644 --- a/ecdsa/signing/round_5.go +++ b/ecdsa/signing/round_5.go @@ -46,8 +46,14 @@ func (round *round5) Start() *tss.Error { if err != nil { return round.WrapError(errors.New("failed to unmarshal bigGamma proof"), Pj) } - contextJ := common.AppendUint64ToBytesSlice(round.temp.ssid, uint64(j)) - ok = proof.VerifyWithSession(contextJ, bigGammaJPoint) + if round.ProtocolMode() == tss.ProtocolModeLegacy { + ok = proof.Verify(bigGammaJPoint) + } else { + ok = proof.VerifyWithSession( + round.proofContext(j)[0], + bigGammaJPoint, + ) + } if !ok { return round.WrapError(errors.New("failed to prove bigGamma"), Pj) } diff --git a/ecdsa/signing/round_6.go b/ecdsa/signing/round_6.go index 95da829a..3afd79c0 100644 --- a/ecdsa/signing/round_6.go +++ b/ecdsa/signing/round_6.go @@ -11,7 +11,6 @@ import ( errors2 "github.com/pkg/errors" - "github.com/bnb-chain/tss-lib/common" "github.com/bnb-chain/tss-lib/crypto/schnorr" "github.com/bnb-chain/tss-lib/tss" ) @@ -25,12 +24,37 @@ func (round *round6) Start() *tss.Error { round.resetOK() i := round.PartyID().Index - contextI := common.AppendUint64ToBytesSlice(round.temp.ssid, uint64(i)) - piAi, err := schnorr.NewZKProofWithSession(contextI, round.temp.roi, round.temp.bigAi) + var piAi *schnorr.ZKProof + var err error + if round.ProtocolMode() == tss.ProtocolModeLegacy { + piAi, err = schnorr.NewZKProof(round.temp.roi, round.temp.bigAi) + } else { + piAi, err = schnorr.NewZKProofWithSession( + round.proofContext(i)[0], + round.temp.roi, + round.temp.bigAi, + ) + } if err != nil { return round.WrapError(errors2.Wrapf(err, "NewZKProof(roi, bigAi)")) } - piV, err := schnorr.NewZKVProofWithSession(contextI, round.temp.bigVi, round.temp.bigR, round.temp.si, round.temp.li) + var piV *schnorr.ZKVProof + if round.ProtocolMode() == tss.ProtocolModeLegacy { + piV, err = schnorr.NewZKVProof( + round.temp.bigVi, + round.temp.bigR, + round.temp.si, + round.temp.li, + ) + } else { + piV, err = schnorr.NewZKVProofWithSession( + round.proofContext(i)[0], + round.temp.bigVi, + round.temp.bigR, + round.temp.si, + round.temp.li, + ) + } if err != nil { return round.WrapError(errors2.Wrapf(err, "NewZKVProof(bigVi, bigR, si, li)")) } diff --git a/ecdsa/signing/round_7.go b/ecdsa/signing/round_7.go index fb2c86d3..b60bd9fb 100644 --- a/ecdsa/signing/round_7.go +++ b/ecdsa/signing/round_7.go @@ -51,13 +51,35 @@ func (round *round7) Start() *tss.Error { return round.WrapError(errors2.Wrapf(err, "NewECPoint(bigAj)"), Pj) } bigAjs[j] = bigAj - contextJ := common.AppendUint64ToBytesSlice(round.temp.ssid, uint64(j)) pijA, err := r6msg.UnmarshalZKProof(round.Params().EC()) - if err != nil || !pijA.VerifyWithSession(contextJ, bigAj) { + validProofA := false + if err == nil { + if round.ProtocolMode() == tss.ProtocolModeLegacy { + validProofA = pijA.Verify(bigAj) + } else { + validProofA = pijA.VerifyWithSession( + round.proofContext(j)[0], + bigAj, + ) + } + } + if !validProofA { return round.WrapError(errors.New("schnorr verify for Aj failed"), Pj) } pijV, err := r6msg.UnmarshalZKVProof(round.Params().EC()) - if err != nil || !pijV.VerifyWithSession(contextJ, bigVj, round.temp.bigR) { + validProofV := false + if err == nil { + if round.ProtocolMode() == tss.ProtocolModeLegacy { + validProofV = pijV.Verify(bigVj, round.temp.bigR) + } else { + validProofV = pijV.VerifyWithSession( + round.proofContext(j)[0], + bigVj, + round.temp.bigR, + ) + } + } + if !validProofV { return round.WrapError(errors.New("vverify for Vj failed"), Pj) } } diff --git a/ecdsa/signing/round_9_test.go b/ecdsa/signing/round_9_test.go index a0963956..de8c985d 100644 --- a/ecdsa/signing/round_9_test.go +++ b/ecdsa/signing/round_9_test.go @@ -193,6 +193,7 @@ func TestSigning_Start_RejectsInvalidMessage(t *testing.T) { endCh := make(chan common.SignatureData, len(signPIDs)) params := tss.NewParameters(tss.S256(), p2pCtx, signPIDs[0], len(signPIDs), testThreshold) + params.SetProtocolMode(tss.ProtocolModeSecurityV2) params.SetSessionNonce(big.NewInt(1)) P := NewLocalParty(msg, params, keys[0], outCh, endCh, 32).(*LocalParty) diff --git a/ecdsa/signing/rounds.go b/ecdsa/signing/rounds.go index a5856689..88462948 100644 --- a/ecdsa/signing/rounds.go +++ b/ecdsa/signing/rounds.go @@ -125,6 +125,22 @@ func (round *base) resetOK() { } } +// proofContext returns the immutable transcript selection in variadic-call +// form. Legacy parties pass no session and therefore reproduce the historical +// untagged challenges. Security-v2 parties bind every proof to the ceremony +// SSID and the producing party. +func (round *base) proofContext(index int) [][]byte { + if round.ProtocolMode() == tss.ProtocolModeSecurityV2 { + return [][]byte{ + common.AppendUint64ToBytesSlice( + round.temp.ssid, + uint64(index), + ), + } + } + return nil +} + // getSSID derives the session-binding identifier for signing. // // Callers must invoke this exactly once, in round 1, and store the result in diff --git a/testdata/legacy_transcript/README.md b/testdata/legacy_transcript/README.md new file mode 100644 index 00000000..11c16cc5 --- /dev/null +++ b/testdata/legacy_transcript/README.md @@ -0,0 +1,63 @@ +# R01 legacy transcript vectors + +This directory contains deterministic cross-version qualification evidence for +the transcript-compatible legacy mode. Private values and deterministic random +streams in these files are test fixtures only and must never be used by a live +protocol. + +`prior_v2.5.2.json` was generated with +`threshold-network/tss-lib@2e712689cfbe`. `r1_fixed.json` was generated from +the R01 compatibility patch. Each document records the Go toolchain, exact +input-fixture digests, proof-source digest, public inputs, challenges, proof +scalars, and the serialized TSS messages that carry every mandatory family. +In particular, `keygen_round1.wire` is a fixed broadcast containing both DLN +slots and both ModProof slots. `dln.carrier_wire_sha256` and +`mod.carrier_wire_sha256` independently bind their proof records to those shared +wire bytes without duplicating the large message. The fixture places the +qualified proof in each paired slot so the serialized carrier adds no second, +unrecorded proof oracle. Range, Bob/BobWC, and FactorProof retain their own +signing/keygen carrier messages. The adjacent SHA-256 sidecars cover the raw JSON +bytes. + +The two documents differ only in their provenance object. After deleting that +object and canonicalizing the JSON, every DLN, range, Bob, BobWC, ModProof, and +FactorProof public input, challenge, proof scalar, and serialized message is +byte-for-byte identical. The checked-in raw-document digests are: + +- PRIOR: `41c0e14b086cb3046353298887edb9ba08e2706fd38df572f425ff5954bb9fc9` +- R1 fixed: `5d0ebead52362cda3eb8f7b14afc5e1d161e9bd531bb2b0a79f0c643b35e0b09` + +The R1 proof-source digest recorded in its provenance is +`69a2480cadd102d35c0b017f448733c50645e3bc1148b869fe84f03ae4850e79`. + +The proof-source digest is SHA-256 over this ordered sequence, concatenating +each repository-relative path, one NUL byte, and the file bytes: + +``` +crypto/dlnproof/proof.go +crypto/mta/range_proof.go +crypto/mta/proofs.go +crypto/paillier/mod_proof.go +crypto/paillier/factor_proof.go +common/hash.go +common/hash_utils.go +common/random.go +ecdsa/keygen/messages.go +ecdsa/signing/messages.go +``` + +Run both independent directions from the repository root: + +```sh +./testdata/legacy_transcript/verify.sh +``` + +The first oracle is the checked-out implementation verifying PRIOR-generated +proofs. The second runs the same parser and equations in a nested module pinned +to the historical commit, verifying R1-generated proofs. The checked-in +`historical/go.mod.fixture` and `historical/go.sum.fixture` are copied into a +temporary module for that direction. The `.fixture` suffix is intentional: Go +prunes nested modules from a parent module zip, while ordinary fixture files are +part of the immutable module keep-core downloads. The pinned fixture therefore +makes the historical identity independent of a developer's module cache without +disappearing from the release artifact being qualified. diff --git a/testdata/legacy_transcript/historical/go.mod.fixture b/testdata/legacy_transcript/historical/go.mod.fixture new file mode 100644 index 00000000..35224832 --- /dev/null +++ b/testdata/legacy_transcript/historical/go.mod.fixture @@ -0,0 +1,7 @@ +module tss-legacy-vector-oracle + +go 1.16 + +require github.com/bnb-chain/tss-lib v1.3.5 + +replace github.com/bnb-chain/tss-lib => github.com/threshold-network/tss-lib v0.0.0-20230901144531-2e712689cfbe diff --git a/testdata/legacy_transcript/historical/go.sum.fixture b/testdata/legacy_transcript/historical/go.sum.fixture new file mode 100644 index 00000000..b067e518 --- /dev/null +++ b/testdata/legacy_transcript/historical/go.sum.fixture @@ -0,0 +1,80 @@ +bou.ke/monkey v1.0.1/go.mod h1:FgHuK96Rv2Nlf+0u1OOVDpCMdsWyOFmeeketDHE7LIg= +github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= +github.com/agl/ed25519 v0.0.0-20170116200512-5312a6153412 h1:w1UutsfOrms1J05zt7ISrnJIXKzwaspym5BTKGx93EI= +github.com/agl/ed25519 v0.0.0-20170116200512-5312a6153412/go.mod h1:WPjqKcmVOxf0XSf3YxCJs6N6AOSrOx3obionmG7T0y0= +github.com/btcsuite/btcd v0.0.0-20190629003639-c26ffa870fd8 h1:mOg8/RgDSHTQ1R0IR+LMDuW4TDShPv+JzYHuR4GLoNA= +github.com/btcsuite/btcd v0.0.0-20190629003639-c26ffa870fd8/go.mod h1:3J08xEfcugPacsc34/LKRU2yO7YmuT8yt28J8k2+rrI= +github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= +github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d h1:yJzD/yFppdVCf6ApMkVy8cUxV0XrxdP9rVf6D87/Mng= +github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= +github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg= +github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY= +github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= +github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= +github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= +github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/decred/dcrd/dcrec/edwards/v2 v2.0.0 h1:E5KszxGgpjpmW8vN811G6rBAZg0/S/DftdGqN4FW5x4= +github.com/decred/dcrd/dcrec/edwards/v2 v2.0.0/go.mod h1:d0H8xGMWbiIQP7gN3v2rByWUcuZPm9YsgmnfoxgbINc= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/gogo/protobuf v1.2.1 h1:/s5zKNz0uPFCZ5hddgPdo2TK2TVrUNMn0OOX8/aZMTE= +github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-multierror v1.0.0 h1:iVjPR7a6H0tWELX5NxNe7bYopibicUzc7uPribsnS6o= +github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/ipfs/go-log v0.0.1 h1:9XTUN/rW64BCG1YhPK9Hoy3q8nr4gOmHHBpgFdfw6Lc= +github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= +github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= +github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= +github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ= +github.com/mattn/go-colorable v0.1.2 h1:/bC9yWikZXAL9uJdulbSfyVNIR3n3trXl+v8+1sx8mU= +github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE= +github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU= +github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJG+0mI8eUu6xqkFDYS2kb2saOteoSB3cE= +github.com/otiai10/mint v1.2.4/go.mod h1:d+b7n/0R3tdyUYYylALXpWQ/kTN+QobSq/4SRGBkR3M= +github.com/otiai10/primes v0.0.0-20180210170552-f6d2a1ba97c4 h1:blMAhTXF6uL1+e3eVSajjLT43Cc0U8mU1gcigbbolJM= +github.com/otiai10/primes v0.0.0-20180210170552-f6d2a1ba97c4/go.mod h1:UmSP7QeU3XmAdGu5+dnrTJqjBc+IscpVZkQzk473cjM= +github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/threshold-network/tss-lib v0.0.0-20230901144531-2e712689cfbe h1:dOKhoYxZjXwFIyGnxgU+Sa1obZPMHRhu6e44oOLkzU4= +github.com/threshold-network/tss-lib v0.0.0-20230901144531-2e712689cfbe/go.mod h1:o3zAAo7A88ZJnCE1qpjy1hTqPn+GPQlxRsj8soz14UU= +github.com/whyrusleeping/go-logging v0.0.0-20170515211332-0457bb6b88fc h1:9lDbC6Rz4bwmou+oE6Dt4Cb2BGMur5eR/GYptkKUVHo= +github.com/whyrusleeping/go-logging v0.0.0-20170515211332-0457bb6b88fc/go.mod h1:bopw91TMyo8J3tvftk8xmU2kPmlrt4nScJQZU2hE5EM= +golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44 h1:9lP3x0pW80sDI6t1UMSLA4to18W7R7imwAI/sWS9S8Q= +golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190227160552-c95aed5357e7/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190712062909-fae7ac547cb7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= +google.golang.org/protobuf v1.27.1 h1:SnqbnDw1V7RiZcXPx5MEeqPv2s79L9i7BJUlG/+RurQ= +google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= diff --git a/testdata/legacy_transcript/oracle/main.go b/testdata/legacy_transcript/oracle/main.go new file mode 100644 index 00000000..ce5b5973 --- /dev/null +++ b/testdata/legacy_transcript/oracle/main.go @@ -0,0 +1,557 @@ +package main + +import ( + "bytes" + cryptorand "crypto/rand" + "crypto/sha256" + "crypto/sha512" + "encoding/binary" + "encoding/hex" + "encoding/json" + "fmt" + "math/big" + "os" + "runtime" + + "github.com/bnb-chain/tss-lib/common" + "github.com/bnb-chain/tss-lib/crypto" + "github.com/bnb-chain/tss-lib/crypto/dlnproof" + "github.com/bnb-chain/tss-lib/crypto/mta" + "github.com/bnb-chain/tss-lib/crypto/paillier" + "github.com/bnb-chain/tss-lib/crypto/vss" + "github.com/bnb-chain/tss-lib/ecdsa/keygen" + "github.com/bnb-chain/tss-lib/ecdsa/signing" + "github.com/bnb-chain/tss-lib/tss" +) + +type deterministicReader struct { + seed []byte + counter uint64 + buffer []byte +} + +func (r *deterministicReader) Read(output []byte) (int, error) { + total := len(output) + for len(output) > 0 { + if len(r.buffer) == 0 { + counter := make([]byte, 8) + binary.BigEndian.PutUint64(counter, r.counter) + digest := sha512.Sum512(append(append([]byte{}, r.seed...), counter...)) + r.buffer = digest[:] + r.counter++ + } + copied := copy(output, r.buffer) + output = output[copied:] + r.buffer = r.buffer[copied:] + } + return total, nil +} + +func fixedRandom(label string) { + cryptorand.Reader = &deterministicReader{seed: []byte("R01/" + label)} +} + +func h(value *big.Int) string { + if value == nil { + return "" + } + return value.Text(16) +} + +func hs(values []*big.Int) []string { + result := make([]string, len(values)) + for i, value := range values { + result[i] = h(value) + } + return result +} + +func bhs(values [][]byte) []string { + result := make([]string, len(values)) + for i, value := range values { + result[i] = hex.EncodeToString(value) + } + return result +} + +func bools(values []bool) []bool { return append([]bool(nil), values...) } + +func wire(message tss.ParsedMessage) string { + value := wireBytes(message) + return hex.EncodeToString(value) +} + +func wireBytes(message tss.ParsedMessage) []byte { + value, _, err := message.WireBytes() + if err != nil { + panic(err) + } + return value +} + +func encrypt(pk *paillier.PublicKey, message, randomness *big.Int) *big.Int { + mod := common.ModInt(pk.NSquare()) + return mod.Mul( + mod.Exp(pk.Gamma(), message), + mod.Exp(randomness, pk.N), + ) +} + +type proofRecord struct { + Inputs map[string]string `json:"inputs"` + Alpha []string `json:"alpha"` + T []string `json:"t"` + Proof []string `json:"proof"` + WCProof []string `json:"wc_proof"` + W string `json:"w"` + X []string `json:"x"` + A []bool `json:"a"` + B []bool `json:"b"` + Z []string `json:"z"` + Wire string `json:"wire"` + // CarrierWireSHA256 binds a proof family to a shared serialized carrier + // stored once elsewhere in the document. Keygen round 1 carries both DLN + // and ModProof, and duplicating its large wire bytes in both proof records + // would add no evidence. + CarrierWireSHA256 string `json:"carrier_wire_sha256"` +} + +type wireRecord struct { + Wire string `json:"wire"` +} + +type vectorDocument struct { + DLN proofRecord `json:"dln"` + Range proofRecord `json:"range"` + Bob proofRecord `json:"bob"` + Mod proofRecord `json:"mod"` + Factor proofRecord `json:"factor"` + KeygenRound1 wireRecord `json:"keygen_round1"` +} + +func parseHex(value string) *big.Int { + result, ok := new(big.Int).SetString(value, 16) + if !ok { + panic("invalid hex integer") + } + return result +} + +func parseHexes(values []string) []*big.Int { + result := make([]*big.Int, len(values)) + for i, value := range values { + result[i] = parseHex(value) + } + return result +} + +func parseBytes(values []string) [][]byte { + result := make([][]byte, len(values)) + for i, value := range values { + decoded, err := hex.DecodeString(value) + if err != nil { + panic(err) + } + result[i] = decoded + } + return result +} + +func verifyDocument(path string) { + raw, err := os.ReadFile(path) + if err != nil { + panic(err) + } + var document vectorDocument + if err := json.Unmarshal(raw, &document); err != nil { + panic(err) + } + _, partyIDs, err := keygen.LoadKeygenTestFixtures(2) + if err != nil { + panic(err) + } + + dlnAlpha := parseHexes(document.DLN.Alpha) + dlnT := parseHexes(document.DLN.T) + dln, err := dlnproof.UnmarshalDLNProof( + common.BigIntsToBytes(dlnAlpha), + common.BigIntsToBytes(dlnT), + ) + if err != nil { + panic(err) + } + dlnOK := dln.Verify( + parseHex(document.DLN.Inputs["h1"]), + parseHex(document.DLN.Inputs["h2"]), + parseHex(document.DLN.Inputs["n"]), + ) + + rangeProof, err := mta.RangeProofAliceFromBytes(parseBytes(document.Range.Proof)) + if err != nil { + panic(err) + } + rangePK := &paillier.PublicKey{N: parseHex(document.Range.Inputs["pk_n"])} + rangeOK := rangeProof.Verify( + tss.EC(), + rangePK, + parseHex(document.Range.Inputs["n_tilde"]), + parseHex(document.Range.Inputs["h1"]), + parseHex(document.Range.Inputs["h2"]), + parseHex(document.Range.Inputs["c"]), + ) + rangeWireOK := wire(signing.NewSignRound1Message1( + partyIDs[1], + partyIDs[0], + parseHex(document.Range.Inputs["c"]), + rangeProof, + )) == document.Range.Wire + + bob, err := mta.ProofBobFromBytes(parseBytes(document.Bob.Proof)) + if err != nil { + panic(err) + } + bobWC, err := mta.ProofBobWCFromBytes(tss.EC(), parseBytes(document.Bob.WCProof)) + if err != nil { + panic(err) + } + bobPK := &paillier.PublicKey{N: parseHex(document.Bob.Inputs["pk_n"])} + bobArgs := []*big.Int{ + parseHex(document.Bob.Inputs["n_tilde"]), + parseHex(document.Bob.Inputs["h1"]), + parseHex(document.Bob.Inputs["h2"]), + parseHex(document.Bob.Inputs["c1"]), + parseHex(document.Bob.Inputs["c2"]), + } + bobOK := bob.Verify(tss.EC(), bobPK, bobArgs[0], bobArgs[1], bobArgs[2], bobArgs[3], bobArgs[4]) + bobX := crypto.ScalarBaseMult(tss.EC(), parseHex(document.Bob.Inputs["x"])) + bobWCOK := bobWC.Verify(tss.EC(), bobPK, bobArgs[0], bobArgs[1], bobArgs[2], bobArgs[3], bobArgs[4], bobX) + bobWireOK := wire(signing.NewSignRound2Message( + partyIDs[1], + partyIDs[0], + bobArgs[3], + bob, + bobArgs[4], + bobWC, + )) == document.Bob.Wire + + modX := parseHexes(document.Mod.X) + modZ := parseHexes(document.Mod.Z) + modProof, err := paillier.UnmarshalModProof( + parseHex(document.Mod.W).Bytes(), + common.BigIntsToBytes(modX), + document.Mod.A, + document.Mod.B, + common.BigIntsToBytes(modZ), + ) + if err != nil { + panic(err) + } + modOK, modErr := modProof.ModVerify(parseHex(document.Mod.Inputs["n"])) + keygenRound1Message, keygenRound1Err := keygen.NewKGRound1Message( + partyIDs[0], + big.NewInt(1), + &paillier.PublicKey{N: parseHex(document.Mod.Inputs["n"])}, + parseHex(document.DLN.Inputs["n"]), + parseHex(document.DLN.Inputs["h1"]), + parseHex(document.DLN.Inputs["h2"]), + dln, + dln, + modProof, + modProof, + ) + var keygenRound1Wire []byte + if keygenRound1Err == nil { + keygenRound1Wire = wireBytes(keygenRound1Message) + } + keygenRound1WireDigest := sha256.Sum256(keygenRound1Wire) + keygenRound1WireDigestHex := hex.EncodeToString(keygenRound1WireDigest[:]) + keygenRound1WireOK := keygenRound1Err == nil && + document.KeygenRound1.Wire != "" && + hex.EncodeToString(keygenRound1Wire) == document.KeygenRound1.Wire && + document.DLN.CarrierWireSHA256 == keygenRound1WireDigestHex && + document.Mod.CarrierWireSHA256 == keygenRound1WireDigestHex + + factorValues := parseHexes(document.Factor.Proof) + factorProof := paillier.FactorProof{ + P: factorValues[0], Q: factorValues[1], A: factorValues[2], + B: factorValues[3], T: factorValues[4], Sigma: factorValues[5], + Z1: factorValues[6], Z2: factorValues[7], W1: factorValues[8], + W2: factorValues[9], V: factorValues[10], + } + factorOK, factorErr := factorProof.FactorVerify( + parseHex(document.Factor.Inputs["pk_n"]), + parseHex(document.Factor.Inputs["n"]), + parseHex(document.Factor.Inputs["s"]), + parseHex(document.Factor.Inputs["t"]), + ) + factorWireOK := wire(keygen.NewKGRound2Message1( + partyIDs[1], + partyIDs[0], + &vss.Share{Threshold: 1, ID: big.NewInt(1), Share: big.NewInt(2)}, + &factorProof, + &factorProof, + )) == document.Factor.Wire + + fmt.Printf( + "dln=%t dln_mod_keygen_round1_wire=%t range=%t range_wire=%t bob=%t bob_wc=%t bob_wire=%t mod=%t mod_err=%v factor=%t factor_wire=%t factor_err=%v\n", + dlnOK, keygenRound1WireOK, rangeOK, rangeWireOK, bobOK, bobWCOK, + bobWireOK, modOK, modErr, factorOK, factorWireOK, factorErr, + ) + if !dlnOK || !keygenRound1WireOK || !rangeOK || !rangeWireOK || + !bobOK || !bobWCOK || + !bobWireOK || !modOK || modErr != nil || !factorOK || + !factorWireOK || factorErr != nil { + os.Exit(1) + } +} + +// compareDocuments proves the byte-compatibility statement the two checked-in +// vectors are intended to make. Provenance differs by construction; every +// other JSON value — fixed public input, challenge, proof scalar, and wire +// message — must have the same canonical encoding. +func compareDocuments(priorPath, r1Path string) { + canonical := func(path string) []byte { + raw, err := os.ReadFile(path) + if err != nil { + panic(err) + } + + var document map[string]json.RawMessage + if err := json.Unmarshal(raw, &document); err != nil { + panic(err) + } + delete(document, "provenance") + + encoded, err := json.Marshal(document) + if err != nil { + panic(err) + } + return encoded + } + + if !bytes.Equal(canonical(priorPath), canonical(r1Path)) { + fmt.Fprintln(os.Stderr, "PRIOR and R1 legacy vectors differ outside provenance") + os.Exit(1) + } + fmt.Println("canonical_legacy_vectors_equal=true") +} + +func main() { + if len(os.Args) == 2 { + verifyDocument(os.Args[1]) + return + } + if len(os.Args) == 3 { + compareDocuments(os.Args[1], os.Args[2]) + return + } + originalRandom := cryptorand.Reader + defer func() { cryptorand.Reader = originalRandom }() + + keys, partyIDs, err := keygen.LoadKeygenTestFixtures(2) + if err != nil { + panic(err) + } + owner := keys[0] + aux := keys[1] + ec := tss.EC() + q := ec.Params().N + pk := &owner.PaillierSK.PublicKey + + output := map[string]any{ + "schema_version": 1, + "curve": "secp256k1", + "provenance": map[string]any{ + "source_basis": os.Getenv("TSS_VECTOR_SOURCE_BASIS"), + "proof_source_sha256": os.Getenv("TSS_VECTOR_PROOF_SOURCE_SHA256"), + "go_toolchain": runtime.Version(), + "input_fixtures": map[string]string{ + "keygen_data_0.json": os.Getenv("TSS_VECTOR_INPUT_0_SHA256"), + "keygen_data_1.json": os.Getenv("TSS_VECTOR_INPUT_1_SHA256"), + }, + "random_stream": "SHA-512 blocks over UTF-8 'R01/' + proof label + uint64 big-endian counter; crypto/rand.Reader is replaced only in this generator", + }, + } + + fixedRandom("dln") + dln := dlnproof.NewDLNProof( + owner.H1i, + owner.H2i, + owner.Alpha, + owner.P, + owner.Q, + owner.NTildei, + ) + if !dln.Verify(owner.H1i, owner.H2i, owner.NTildei) { + panic("dln proof did not verify") + } + dlnInputs := append( + []*big.Int{owner.H1i, owner.H2i, owner.NTildei}, + dln.Alpha[:]..., + ) + output["dln"] = map[string]any{ + "inputs": map[string]string{ + "h1": h(owner.H1i), "h2": h(owner.H2i), "x": h(owner.Alpha), + "p": h(owner.P), "q": h(owner.Q), "n": h(owner.NTildei), + }, + "challenge": h(common.SHA512_256i(dlnInputs...)), + "alpha": hs(dln.Alpha[:]), + "t": hs(dln.T[:]), + } + + m := big.NewInt(5) + rangeR := big.NewInt(3) + c := encrypt(pk, m, rangeR) + fixedRandom("range") + rangeProof, err := mta.ProveRangeAlice( + ec, pk, c, aux.NTildei, aux.H1i, aux.H2i, m, rangeR, + ) + if err != nil || !rangeProof.Verify(ec, pk, aux.NTildei, aux.H1i, aux.H2i, c) { + panic(fmt.Sprintf("range proof failed: %v", err)) + } + rangeBytes := rangeProof.Bytes() + rangeMessage := signing.NewSignRound1Message1(partyIDs[1], partyIDs[0], c, rangeProof) + output["range"] = map[string]any{ + "inputs": map[string]string{ + "pk_n": h(pk.N), "n_tilde": h(aux.NTildei), "h1": h(aux.H1i), + "h2": h(aux.H2i), "m": h(m), "r": h(rangeR), "c": h(c), + }, + "challenge": h(common.HashToN(q, append(pk.AsInts(), c, rangeProof.Z, rangeProof.U, rangeProof.W)...)), + "proof": bhs(rangeBytes[:]), + "wire": wire(rangeMessage), + } + + x := big.NewInt(7) + y := big.NewInt(11) + bobR := big.NewInt(2) + c1 := c + modNSquared := common.ModInt(pk.NSquare()) + c2 := modNSquared.Mul( + modNSquared.Exp(c1, x), + modNSquared.Mul( + modNSquared.Exp(pk.Gamma(), y), + modNSquared.Exp(bobR, pk.N), + ), + ) + fixedRandom("bob") + bob, err := mta.ProveBob( + ec, pk, aux.NTildei, aux.H1i, aux.H2i, c1, c2, x, y, bobR, + ) + if err != nil || !bob.Verify(ec, pk, aux.NTildei, aux.H1i, aux.H2i, c1, c2) { + panic(fmt.Sprintf("bob proof failed: %v", err)) + } + fixedRandom("bob-wc") + X := crypto.ScalarBaseMult(ec, x) + bobWC, err := mta.ProveBobWC( + ec, pk, aux.NTildei, aux.H1i, aux.H2i, c1, c2, x, y, bobR, X, + ) + if err != nil || !bobWC.Verify(ec, pk, aux.NTildei, aux.H1i, aux.H2i, c1, c2, X) { + panic(fmt.Sprintf("bob-wc proof failed: %v", err)) + } + bobBytes := bob.Bytes() + bobWCBytes := bobWC.Bytes() + bobMessage := signing.NewSignRound2Message( + partyIDs[1], partyIDs[0], c1, bob, c2, bobWC, + ) + bobChallenge := common.HashToN( + q, + append(pk.AsInts(), c1, c2, bob.Z, bob.ZPrm, bob.T, bob.V, bob.W)..., + ) + bobWCChallenge := common.HashToN( + q, + append( + pk.AsInts(), + X.X(), X.Y(), c1, c2, bobWC.U.X(), bobWC.U.Y(), bobWC.Z, + bobWC.ZPrm, bobWC.T, bobWC.V, bobWC.W, + )..., + ) + output["bob"] = map[string]any{ + "inputs": map[string]string{ + "pk_n": h(pk.N), "n_tilde": h(aux.NTildei), "h1": h(aux.H1i), + "h2": h(aux.H2i), "c1": h(c1), "c2": h(c2), "x": h(x), + "y": h(y), "r": h(bobR), + }, + "challenge": h(bobChallenge), + "proof": bhs(bobBytes[:]), + "wc_x": []string{h(X.X()), h(X.Y())}, + "wc_challenge": h(bobWCChallenge), + "wc_proof": bhs(bobWCBytes[:]), + "wire": wire(bobMessage), + } + + fixedRandom("mod") + modProof := owner.PaillierSK.ModProof() + if ok, err := modProof.ModVerify(pk.N); err != nil || !ok { + panic(fmt.Sprintf("mod proof failed: %v", err)) + } + modChallenges := paillier.ModChallenge(pk.N, modProof.W) + keygenRound1Message, err := keygen.NewKGRound1Message( + partyIDs[0], + big.NewInt(1), + pk, + owner.NTildei, + owner.H1i, + owner.H2i, + dln, + dln, + modProof, + modProof, + ) + if err != nil { + panic(fmt.Sprintf("keygen round-1 message failed: %v", err)) + } + keygenRound1WireBytes := wireBytes(keygenRound1Message) + keygenRound1Wire := hex.EncodeToString(keygenRound1WireBytes) + keygenRound1WireDigest := sha256.Sum256(keygenRound1WireBytes) + keygenRound1WireDigestHex := hex.EncodeToString(keygenRound1WireDigest[:]) + output["keygen_round1"] = map[string]any{"wire": keygenRound1Wire} + dlnRecord := output["dln"].(map[string]any) + dlnRecord["carrier_wire_sha256"] = keygenRound1WireDigestHex + output["mod"] = map[string]any{ + "inputs": map[string]string{"n": h(pk.N)}, + "w": h(modProof.W), + "challenge": hs(modChallenges[:]), + "x": hs(modProof.X[:]), + "a": bools(modProof.A[:]), + "b": bools(modProof.B[:]), + "z": hs(modProof.Z[:]), + "carrier_wire_sha256": keygenRound1WireDigestHex, + } + + fixedRandom("factor") + factorProof := owner.PaillierSK.FactorProof(aux.NTildei, aux.H1i, aux.H2i) + if ok, err := factorProof.FactorVerify(pk.N, aux.NTildei, aux.H1i, aux.H2i); err != nil || !ok { + panic(fmt.Sprintf("factor proof failed: %v", err)) + } + factorChallenge := paillier.FactorChallenge( + aux.NTildei, aux.H1i, aux.H2i, pk.N, + factorProof.P, factorProof.Q, factorProof.A, factorProof.B, + factorProof.T, factorProof.Sigma, + ) + factorMessage := keygen.NewKGRound2Message1( + partyIDs[1], + partyIDs[0], + &vss.Share{Threshold: 1, ID: big.NewInt(1), Share: big.NewInt(2)}, + factorProof, + factorProof, + ) + output["factor"] = map[string]any{ + "inputs": map[string]string{ + "pk_n": h(pk.N), "n": h(aux.NTildei), "s": h(aux.H1i), "t": h(aux.H2i), + }, + "challenge": h(factorChallenge), + "proof": []string{ + h(factorProof.P), h(factorProof.Q), h(factorProof.A), h(factorProof.B), + h(factorProof.T), h(factorProof.Sigma), h(factorProof.Z1), h(factorProof.Z2), + h(factorProof.W1), h(factorProof.W2), h(factorProof.V), + }, + "wire": wire(factorMessage), + } + + encoded, err := json.MarshalIndent(output, "", " ") + if err != nil { + panic(err) + } + encoded = append(encoded, '\n') + fmt.Print(string(encoded)) +} diff --git a/testdata/legacy_transcript/prior_v2.5.2.json b/testdata/legacy_transcript/prior_v2.5.2.json new file mode 100644 index 00000000..dbcb156e --- /dev/null +++ b/testdata/legacy_transcript/prior_v2.5.2.json @@ -0,0 +1,796 @@ +{ + "bob": { + "challenge": "63ce7957914fdb39d718e50414d71e9b1dd4242af37aa1e4f67d43879ffe3e1", + "inputs": { + "c1": "3a0470bc36ddf902d063c077b0e557be98692bd242c9cf3506ff8838fc019f41c09fb4d9a452f2922a72dd1ca9f8216a5efd85c11181d01355c852005f496b5080af601fb4ebf2d23ae45cbabf50ad517b2d2cd1247bf20d98e1739a00456d72cd39a5a7f5d2707c63ad633eac0f0f271ac2a582a79e9fa1988c508577345b695d5752346961510a5328ca33bec0d667d19f85fdbfebe3f9c20eb1fd5c701e6d0aab0b584fca16412874c097dcd6ebf5c6bb28e53e2e6b3cd74ac17130d5ab82f733a302d71a27fa569c82c58e9874866c24cee255245ebe42800999ab18e9ca198e2d518ca20c1c215b8dcd3e741cb9e3cc035102bd8c9e2306233b4c50a4586a484470002453eb61d1d15d1aa76590efe3a20bfc83a2d1477aa60f5215c33a6933ff0848c397e2cc61d3e4dfded65616f37e9864d170df7584ea92094b7dd2a6941a3252047c9704843237a5479708b796dac71cdb6c683ca118395a986bb08aeae0df859e9a001f6e75527d0dfdf2291b9cd690ce400f92a7a4d68fcf70926bbc25dd3369f01c0fc1cdbe9440b5f8f19d3d5174979f5bd1c94ec3e4df0c09f807aef71efae41b27351310374ac7cec30145b9284cb7c266dabf201471b8fbae21f24575a3ba3060b907598200c9607b6f4888c04598a9f0b69246b027d44b2248bf5cf7c915e5769784147786aad77dfa285b398e03580a6f3132c3189da0", + "c2": "47bd93dfb917580a50a07d4256088d264cdea88976a014cdfa3006897db3c14428ad683d28d7cbeb46a68980acea1d46208cbbde05cc059d11a2158ad69d7ab648ca626388dfa4f685bc84fe3e8abdcd7888d150ba5b93bc58184aa7f6ea4c13dbe81df6978a34526de062c313b851229a41b772941c254f582b6d5efb8bfa73a8a8f3345eac51a5c7a132396916b2d4f6e5265ab0d8b51881197c5a9eda07977ae438dfb3716ca4ed01620c34ecca532bc0e68772a0fed6d576a9da65313de26328f790e66449e83631491d4281ba8487828c11a284ea168960461a92d59077676df4b52aa94341d816063275368e055f1c019fe9f952554efcd11e3c1d55875fcc5e40a67f69036fb609106cc27a2daae2561f5b2ca909c126499cf801905e5054df946717e814a6bb592900d7a317a1265640fb3efbc8bcd3c6c15cfc80f8af1670ed765590ebaeaac9f8457b036f3e15d82b26bd96764cc47953ab2f55a45c271b5901955414ea9180262c4d043a2eb690ba866df53c7385a8ed07eb7c26c93118f94d0f2fe485772d2d5033984938c35f7f2d673e17a2d25e344d73ee791d5a898164942cc45e0e089cd1f88ee4bf6adb16ffac5a8d943c67db8fe9dd8c80e7145c170ba3d5290565026537126ddeeb5a9dfcf9fa01132be57ba3b6be6e5912b64cf243c37338930903c6bfaf60c0b249665fae514e4d47baacd6f1add6", + "h1": "f21c50993ff18390db9d37e26621809065359c0ec1a70ec0b90b71dc10a070305519e2dacb54dfee66440cd4219c0bd0e456631c0bd326627c1005f36e02432b03447149a4ce0e62556531fe907bbafd11e1059af12fc1fbfffce9205222e42b02c18622e88eb0dcd22f098a905cecefe4672e7e8abe97044f1b993f5294907a5d595ec23179e82717978d594f205c5c3e904512cd998522b933763b3f0ae56ee684c1743ca21c86b6f98f5200fe352f3c2bc5641d8146077755332834cfa5ff2663af15ca0b7a239be9b661885be6f39455bb4be1c3b54c2d598683c9731ace5f19ea7ed5c1fa85f8e304a50833bd1a66157c92ba2d91f021400d736e39b05", + "h2": "23356a7ac492a79b204f34ad22f474c3fc03f1254d2a4d24ecb68a670f1cacd6c2d6e9522edeb8d8e58da89587ca88ba878bd2d72ed3ce74104996a937d7a5b8e68b26200671757e110764c16b2ac2671e03c56345cca8bfe43eb514a8c7e1f45d05eeda3b4814ce63ccba37d47756efc7436dc899c4fb85832a10d05e11bd3210bbd0223c19fce9535c0d3dcbd3cc29797fc16a25e5465c400fd0ab9e93dc4c8b3ddc0e736bb5034bb20ebee475d4a837979fe6dac91f967a90405268ab6293498592c15d8c556ca5e893189f20cb4f93618818e19ea2fd29b44cb3bd3afd7641d23eb22151f25f37f6c318531d2df923ed299444883313bda323a591c695fa", + "n_tilde": "bd276406344107286ef49a2acde336f5975dc24bfe350d57501071014b374537099933214fee6277bdb4138a1b5127a2f4417c30c9b271dc03e86896522a1b18d25f545932f91ceb5e037712b1d121012c1649a6d07a6acddb225a6804e58ccd9fc88d5c872ed5912c5f4179747b828a3a9740331b0d4e2157ac88b517c8f7e01dc6475d61d60194c31faaa5ae381c2615d7f1c4abe0a3e544811ecf0d1494461066b354a201a78e40e4f289accdfb15445e1248808a31590d7a70659f2c55721ea4a821610bee961924a3af65a0a601d3809d2bb9e223b94c96b2f2ea926af0c2b88b95dd334cd683f3ed3f5c446e918e9b23d219c8a9f58631cc94aecccfc1", + "pk_n": "ab9acc348c6290f126cf3cb35e29b71cef8cf1c98d21f22276d540efb4f2a74a722d2b2ab6fd3e400621de109fa0c82104a6111d476da33c679fd58d32e32551e1f8e4b39fabd9ff7c6e5bf76aa5b7ba72ca79bb72eb68ad72975a6d1cebd0bec34cf56c9cab4d39f6280206b001d6495b6e1c58f3b050be29e078aab5cc45cc201922715dae7f72bc8810380a38c17b7838e6a18b804e2a25d2d22977fa26dc63161130464af47dd5c42dba70a85a0bfa2e3ca4889abb3cdcbecf75165ef6345ef1e58f9929df65ce9bf33a53e8f1ef18c73231c70f21a30c4c21f10693eba687faaf5de5f3b27e020527539b3a8e8358a929bca06c1ff6c3a2720ee19bbcd1", + "r": "2", + "x": "7", + "y": "b" + }, + "proof": [ + "8bde2880f38ef6936972c0db7817b255eddc0317d80fe600368e2039eaf15738c403dccb82e54dde021058477df8b6f79b160c641a55831043de088be0bd6cafcd6cdc5bb2af89c40fa7bfc45e359dc07f2ee7b9d355fc555762a5e3647dbd4ebe97e33ac754bec7659b9b18beeee9aec42ed433fc0d6efe5b9447ee847a22432fbf5b52b9693937963389de40985b255aeeb5ffbac06cd92ba79dcfa994a183e2d0b53fbaeb01dcd0aa69c82bb34d1e0ee4125198d9cfd5cd1faa4b6af0e3bbb2398e9f1d413b5949fba6ce4044cbaf76a684a1271aa6274fe8e66cc9c7769f7d388f812ea33d036b84e39385d0e9b4c4b5933c78a221ece50e28ae07eebd97", + "7453ef91cebb6e7fb2b7b57bdb60bf5a9f077122ab7073072ced80075e1e6b8c846c2e19738bba47e03ad99ff17cbeb88ef71c30b71999b155e3142f16c35c27973914b6d2e12eff81104b2ba7d8fbb8ae49932b171bf5173e31a8e6dbb1678b9d124bc404fb0939b9ba5e47aac22540b6c185531564d287c2f8c9349c47d893500e57b66bb58e9c189c32dd1d99edb8b7937e2449e1210207077c0a2007aa8ddf7393aab05d6107c10d2bef888e49132023bb05a1d5dbd7f8d9d8af71b0b44e2abbaf17996fa64206f11c80938619b71b26dba7ccc77d9619d94f98df9793b8d75a8d4cce21b94303c82c5fd8265fa54da5354ba756489986eefdfc980530be", + "543ccec0195767b77659baae6f901999cec4039131aaffd53c2bbcfb0ec5e0ba6e3f98c5e67ad0ed66729e66adbad5a9710a8d4d972dc4eb854f571a7985cbf20d1b8aafedc91797ed704e58e2d3322e8c262104f8d368432816bba5adbf0634465391ab8c6ba57dcdda9866313d53a0ee9f67c5afe213ad38e20f70a0efe7a249a96a01d8ea947ce1e1e7fa20c1d34c5ef223ee020343b6497486e4f41f689d2528858ce3faf7e3b37978f25f56adf32714f706d091f9a6a1b92d40e521f257aab96cf949cf3e4e5cf41a9e3de896beef139990d42c6ed8038e64ee690c12e9d30e776feef0c832cff7f3fcc4a1117fbdbc42e2ecb951aaf25656f97aba9099", + "56f6e277b53274933ab2f0ece8cf4dc41debf17b15dbbf3ff1840f9c4a654ce46a8e9568a415244fbf9e624d32e2f2d9136212ebf7d9dc562fa8a4e57228de3fb50939ed252aa38b19402e5e2179bb4d412cc7360341fad6493adcfecf52a481369f7cfa792311805f97660fcc23dbe3e06f8a3b947be9f17c62edc221993f347c1b0192d8a8c7b88dc1eed8f89f68bfa73b11e0b5a6a9b286805aeec9f99b02eea841c41377a295910db3f406bb281c329f97be7075c32ac1b4e5cdfaa5c6c8ba93cd1fcd14d3880d79132f72e2b3b40c5ecb75b81f7192c1439090103c2e5bb0e597da0584ed3d0a86d048b92e7464a06a72f56d9b96cff5a5debee756db30bdfa94b47ce817c80003e8180cdced6fe1f7021cb2abe73c08843eb20037ab8bcd0e4ead7596c782a67b2c21e178ba2eae46f40cb593a0b27f93727b22b1732437ecd7543457825d766814e1dea46f62fda2d5829b7278653d114a1a514ebdb594d20d1f6a531af57d19e2e69c58110e4671fa4be0a788c9d7c0bb8314447b8a90c9f0dfd693ff69e3eaf0a9ca1bf36108b178c2b86141c78eefe4d33dae85d92fb4f3d6b5e169d44806d717128113b2fd7e330e23dcb5e266f9460a022ae9d2d1ddb06793e872719e476c5fd67e243dfb13b4e2f130b735b4b848646ccc2e8bf9f555fc4b76e2e7fba11ab66ab6bb1329b758538e2ebf975f7e41fdabd49858", + "3dbf3f51ac2932435af98c8009ae95cde57426175d97345f116e2f503fb2310008d21c9de7ceb50d075a5273da227a4fa9ac0c05b4818ab6d905e2788e518846b1b5ee6242adcaf11d492f13661037ad3b7901f2b4a453574615685675d9df1d7fa442958a2cf13059fb6833a79df03bd7adaf4853184b958667fd267ced7a4c043356e5f78cd6729726d98fcc4ddcfaf469f7ba6873c4483a9dd41e8ea4bb64cf5bb4f0de004699e4ffa4a19559317968e86227c23eff625f0df3132eeb0383aacec697bd80481e4cd5dd6be7c45a9406eed7caef90cae7ef0618bd6278fc300128da12aa931131687dd38b79f4fc6976cd984f08da2855613a9215ddc74bce", + "540c76c8f333a70079a9d576610fddb49d95059622837103af4579c121753b293a176477ee466ef2d0ed8c1198c1c155e3a25a1f28e741df2edececaef54afc127b6962b06fae3673a9550b35b7ae50c8e383a6f6b7b51475c28105b7784902d61fbd52494303a2d02b3e614cafbbf9fcdf25e1d65ba6f2a333069444fda78c1b17a4190a25e491c4ec66b7c0d19807b2f437de3d82b66a39caa92fcae3a2b8b3d647fb25495b9d61ca7d83360ee0141d7fcd4fc2ab8e315271d6bea6dbefd81d58eee1038ab02a9fc95f6935d7d6af384e9b999f55273d59f3387f511f3ecb807a9ee6c22051dcfa49365f0feec6886ab0674492b4ca27e4a598854ecd4b52b", + "c85c9eeceb80e36d13fe5bb9b45810fcf11b7695071465257dc9b4ca1277802523fe2dbb9d9b757c0ee4b3843466bcfe5fd8ae441aa7acd1d570f2f1f551985da3eb749f2e3f5c8ddafe06dda6b293f612274b00fdfc0117dc30ad0e86f28edf", + "b78f9cdb906a066d6f23f4e0e215c63f1227c639da1bf92ae52c23905a17d572287828a86e0b5d86343138721a10af57b7efc85f44cbb10612ef1982262568a8b30de25cfbdbedbd4bce1c99569e8d331c68def4f2bef7fac43409a6d7af67b4456c1a1dce9b7362e648c1ec44ec7bf6cdf77b68b2732c6a7405d8aae337866f27a939c8f5560177dda9827e165c7e4ab061e00b34c16ea99a05283001c48af776d92ee7740c18a5a74713c92f199b509b50b5ddbd956c37a7b6d179a32da0b38105f958ecb8fd92c54db7215d2448f54ee04665b49589ee2b370e8f14c0f3267628f579c5ea09f64b67f808d55a19ac86b35644e8419580189aa78a33ea1d37dd8c3b4d54cf73a5644a2c868f70b88716042fb6d591abbdc98f3115b700f437d21b37693dc5e21d713ef728b96099f59f0f346e30709c4dd09a0071d7c6dcf2ba544b093ffea7c1367858b6489d3a307e4a83374307e9642cf48f2f16b603b1", + "2c73a565fddbb0af31a5133ac3778c33ad52e95aa4cd1cc61440947e7c705a90d4007f9b595ec5dc4c359d63fe72e78537c1f7aa8f3332bdc888c28d70bbc078ad49de5d2ebcc8efe20b635fa640fbf3ec2ff3f1a4b53dca0eac12fc942afdf1d9e161efb1c23092313d140eca1bb16a214b742395031ad333c42636bb2aca3ca4caf55a7f770260c4c6bd96ae98d970125c8405f056635d8dc1483a378b234d20d7620b5bd6cac08e1c27eddce9e035a04fd5c6a33d61aa1011980887eb23afe08d946aa620c749b702fadede552e533af22d02e18d80b40546b4d1244a341fa824f91cc116bd8d73333924477bd7dee77183f9bff21bf0dc063c9a65e2fdab", + "01e3a2864c0ba5e00e7f1a0c31d6e4f4e3bd3d142dd36ba0aa2a1ba275981d8030dbc370efcfafc1ad428ac24d9f2ac0f072648de7c1285df928f2ed2df152f5b5b9d5b4160a41ef5249db7aa4f5032b7a52458388f026be1eab01a23717003919bd4a3abffb691b81960de67600c3c44d79405072c967e755b5d5c508f794abe2f9464bb44315c2ee1293a0e2bda6aebf8f53b7bc198778452cd1f782e366ce972278df6de9833ea63403ad01cff594e90eadf14b31a07318c2b1f29244bf366cd92ac4e08ebf84a2d28edb5ce05e4cdd5fdc6393a04aedcad78863627c847a428b746a8882c3e2732ee42c8933ef4a66c453a2380ce44da322854b3f822e807ef47bc3da5212ef0ac3c7c251f17d078a6f1511d1ebf1a3dcf2b63e66ce5f618a1398ae8f9db70186ccf7cf02678f16a4496682ced8ea1a68c466c034f3dbfa" + ], + "wc_challenge": "d07249c20acbc5694732d9ece8e8ffd157e02aaf7f2ce553a5e3d7e24a748e31", + "wc_proof": [ + "adb6effad30aa2324d64112297579ceaeb62904e09bfa70b1bf37082d708bc5b24bf457f140a35722ba6facfb1998516bef0250979c3f25b8075b9c7f3333afbd1555b46700fbe57be806f923436232b28042fd6d6606edaf14aa56f170ad47366a25de374656838eca57dae372872f98478cfc85dc7392a01a09ee8208da125b1b003ff25c50f7b88845ce22c1b9295945cf668ca731bdcd499467f42e110cbca7ca5df3cebbc70fd6ef44c9fbb6f014fe17e3cb12b8a47844cdbe0bda2afa3254e2a68180e51377b8b32e53f9b474a1b53d01c67a8543cf987b61cf73f28bc10cc5a41cec32b9ed12f702c43610990c4dc38d18ceadb347543bc7f900bab5a", + "aa54428b6fec326957c711f08f95d084aafd00c57505fdbdea98e5e85871c46a8d94c5d142f140eeb6decedd0a07cce8f040fdebc11a69b910e4cbb510c2475e523b013ececfdaf6b580274f4953e8593d495f60b1713d0168a9091087978aa46af774e76fbc94dc5b52dc35decadfc287c981507529930e1a267c704cbf8c8a55156266255bc3846d0b013f8619c9617e10a9cdd248eafe3ca1d285cd47cf789511f05c4fa77b9d767df001f9df22ab00f65100da86ef17df1e3362e1cf5f8ef0124054884412985411bc3557bea9fe9e4c88778b1641d7b4b28b570655bf1c1acc558455bbc8a51ecf55f6bb24dbb5459510e979d5a7c8c220a5fe6cdbbf41", + "44866883b5a4e4e6a9c150433a197c60dd4e44161593d9bdd87bfe7bf94f0e20aaac4d86c0b08b7a1dd2ba3f87254dc16f6b53d62f971ef441fed37ec4bda5baf98b3b3d3a11c33f37938734a86aee6e1706d6db081fe656ef0c912cc75f6b9b763ce9976fccdb0c3867190023b692d61d753b72f28d8df4f6ed48508628db7792026ac10a0f04cea9251f1410721f42cfd900f7067882afc48b485febdd436b1b639350e27e60be124d9ee180fb2666c9f2b07f5af6efa5fcad79f652fe53fc406809a8c389de78222fb8344bda6d1f773c0debfcf5eba0eedfdcd0622bbcc1d9f076d035d703c61ff2733e80bc5fd9de7fe54757760b7d3593d5412650cfc1", + "46aa39a9c23f8b34d2f831b6524f7e15745f1b3bd660473364b4a00cdb4f44018301ebe692f7991e1dd81df4e329de945b85770f1baaf700e6ee2db0c6953c8944ae9f1634886f19c6a315609ebe58f9fa77e5c57c2cb55485873cba59a3c541688af3e5f1c10d195b443eeb0311f5655056195a6ca8200c65c2a1e09bc6a0db5e82cdb6b35f2d03adfe0d6aee54c58325ec60104422b7bcd5d11c7cc3cabdefa34a53220bca6126e5b34cda21f873a2a2b1694fa24019d077516bce625be444cfa27c06f1e4793a71e913af3a1eafabf5d32526b131f5059165fd30e9fb46cd82de26718824fd86fb39864856e87e2e0a010a3dbed621f1a159ead4a68f31c58786feea7ff174b14a1f9947d81e2d9c2882fc2b1b6e1991b96da3067e59770bd61591c1dcb49ca5c65df455c1cb70a659f5cdd5e9affdbcfb65297701d65a8114105591005eeb189f751e55ea7111efa29cb0ce321f897eb0128c9943c8c806b9ac48da46163a486791b8a566842ef9ec538104b2b1b16aa8f8cd57aaf117e482bfd61d3b55b47c2a4b718a00625163066e2ea1511a917bb2b581c1ddf31a45c401aaee51a90373d59bd12965566208b783e35213052bed73fcb7d7bdeeb68714e331b578a605cadcaa1966c43c8f243401b646c576a8754d6207ffe6b23f5d0d292d61a8c3445c16ef950a1a797a8495798863b2b812d54f5b7da4af65ccbe", + "9f5277eea68182f22a4ce9c86f2aba3e353d9fb1da839b9b3d3c3813875ec9c27c50e962f7beba9d9835974adc99b8e1de93f7ee61b2477a22c11532cc79f857bb28d3105bd60804e5c3a514bbee184a85f2fc7ca301ee46f07e5eb935e29683d4d6533b8e4f8de94ae1522e296ae5877f9c6d4a8355554acfa23b36afcc40c32141651ddc389114251a6e88e1477764670eab10c7c62f9e1b8541f32d7fff9273b9955bacbcc1fc3f5190efc2ba1c93de2fe1b592a73a8c517995f5aee6c0993e3eb2036c9ea1c0cfc7593f313c7d16a61740efbe08e0c275e68e7bcba3b3a297e03d3cd6b1cfa6f33b5f16fc524c27b4644c0c11d424e4d1048b6838bb78d5", + "97297e95b386037e28a2758bbf61edd5a01190d03f65307fcd4a634c5b52495203a5014a694fce47ec83e70e624d0b4286590e237ef019f4a7dfdbb73bdfd5c38345659c21cd96bc6f4677c1c9062df520dea601d5af0427c145dd4e63d1168d4355ed021b8a01354ea3f1cea57e010a1d61c73e19c7de59fcda52a9f536ea0ce18ac935a72f0e5a2058e1b53137000a2df662b27a2b380fa992ebe965df4ebe13df9433116560121f2057cc6bc42d85c25418d636251312a6ba58e0f70412b302386bafb1236d91b8152fd7852e986f9ae5021da74909cc3056129bcac8c63bec25b89cd1e04135154c4f160a7e64221c5fbea148aa3190b0bcae307d566cd3", + "8b50b7f2f99ef6f7731d21c699d5e54b61ed86508e7b20bbe309c693cce4751fad1f15cdfaac86149f8d014ad38d7064e11ca4ebb3126c635fce907b93562d71f13ac54196f5cefd8b063793104102ffa4df0e44d7f154587fd98bc6164b3fd9", + "900f33dfac66fc4f3152eebcd4fe5ed1ed605c83cad51dbd43cea633b4f09739c0f181b75fa7251b74b0940d9c34732d09059e2f0aec01992fb10106a8dd09fbd82296d9fefdab8cec51b6aebfa8736436aca720d46299c4404c0a97d36ab46eda750f3ad90e2b1c936ed48ec09ca5539727e40c6ce593bc0f17a4ac4b319d98e9ea86e57f8483b77be3eef5e806f886ba2c5c83cdd8742644428cbe05f1638dbe6f3e133e4400caf54d0969e697edd92e1f1705ebb54841a0700783ae1cdb60f2d0f279fb44963c937c500843268d30f8339d05fb3c967bc5941719ca66b164c718008e7a9bacf16412b47e7694ef8ed5c48ce2bfbb1fbed5c5008ae6cb4af614e5de88beaffcd5e3ef7ac7be6012545f1f622820c08fe5eb630fa4fb8ab85f44e5b14c808a00d33a003e983880f111cbb53ff0a1d1bbab4d0e0e129e564c256f396b9f263116510101682644b4e28334f843c7c92b11b691512ada2c83a7d7", + "4732082fcb43a109070f4c3532c1806c31bdd1ddf34a1e8dca36ad4121ae91ee757cfdf6442a73560b0ec5745a174dabecb74fc84ed9b3d5677ae209e69d7c834a47126ba8aa96e222080d546a9db191785880d25497590de2e74784ce62c364b40caf6b3535378d5440b38f94e9d09831c23762cc878c9ff56fffe825869c4a686af1672a707aa7e59612e389cf5780b7356a7321ad98a44d52f2be85dc3e713359e47339bbd60c6beebdc643010d785116d19b479b4cba4166761019e5647fc32f759c2d1f6c4b6c24b72e868f9281893b11690342e51dc961132502f07dd6862a8eed413b92ba34225014e9556606502d4356720a2ddcc0c2ef8410066f5c", + "93cb7a255c12a952fd8d671fe3359dbd637dbca5d572e43b9755a07c26924e4d6afe85a18fd3dfb886703d2ee086f6e613cbbb001e27dacab63b71db0f91b0ab76acb50e7766d0c99eb0a89ca7257375a4b066b3819ad2a2a30038539e678bafa773662f44771857aa25af0e1003fc6773dcac08c76beccd81159b8ae9f5ba3b570d0a433b450f8a605f93b058edcb4fdf5eb739bbfa51266b2fb27823000f3a402158b9016ab122da57d3930b33e8cb0220930b3c321190bf7dd943db6e7b315892dc04fc1e7a7c43e8e26f7d591b47b2089f04b85265fccecb0e5e80f44e64cafd343177106678f61741f98634f0ff04e5cb19afec778ace97fd691e8481f95e6f64dcf810cb076dcaaa847ed1459233909a285b8d48df65ec3d223cb04050c232eb386e9155cfbffd4b933c960ad9180dc40993ad327b746f6194d0756ce0", + "308130dfb1a5af51c49d3c4501abe5597fc8d71be8d5b3250a7eb02c07404080", + "3b21188060d87440d4df44eef99739ab37c7fddfe05a2dcb4baab8eec71c41f7" + ], + "wc_x": [ + "5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc", + "6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da" + ], + "wire": "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" + }, + "curve": "secp256k1", + "dln": { + "alpha": [ + "9f4ed060c2f28ce0131d66cf9fe18156b3af2f39eff9dd68951b5ebbfe7098467a25634d9ff93d62f6d12d088afbef975be74f4996badee7f7ce8cc87133a86ff1eb57070d1fa7f209dd7afd91caa66346ca9eeabce3d62f087be8b5151255da7049345579a5df84c2ec76ab940d10f26a4a84b36a7f8527592a6fd0c05b6ad650de4474f5c756fa182c2d912e3cec0a7c83b2f46e56eba1e2bf4cd1ccfcc92232f7b7705e9998ba4d49e06b5564d9382f410d0f48988208356a67c983dcb50ef8c6bb4d52846223aa057637fdc0f462ebc7ce0831c78aae471a7bd55f32d773b106b0a342f83b018f56f13cf406c4b43759fc502b54d62da6eff035ba275830", + "66885d76eff62b8c7fa2160d49705be9d1f3312f49aa021fc8c76814c88623cd67e1211474574a90a0940be8491340134a0b5c613fcc23c3bc7fd84a7d190299ae94b9e0bf092b98b0f43e550c93f5a35406b2646f0e3d344b9e822bbe3231caf857b1171ff1a83ac2761ce6175645359011237002a798da147e2180328f5bc5b5915bbe2a17d5ad6277272d831020f19f4523c7504385a7e70127439b5b476aa45550072da95ca2b8f581fb4e1767ea09ad65b59582dc056f84b2f23f3f129ee1047fa6e431b3756ae7e065abd9aa6be118923e0c64f73cdb6cdd34ddb96d9e07034288aca3f3f5dbe6f0b91200e2af82952121a469b09dafed29992fdec85d", + "36206638dab487f7868adb46aa1da6891fb36cdf8dae1427436ae6e4ed620f438140dfddaca85a0866c879745b153ca0a48a31ff9bedc514ba5ad4cf6086ba2c0f2f8a07cefdcaa5ebd0a10423b2ae74181f4f7907b80fdaf82c40ebe76a2c2a304a1662a5837a94e78ac1237bee4269d6e11cde34ef6801f2dcfe87a9e65ee2109e57b0fe0b6ef9e7dff6b878a62d2ff0f29f38ac2d3d63570682cc88a95223d37d0ce37a9ef0fa32f3162190e9b7fe84d78108c6be8d04a728d0c33583864e23aa164295a3cdad032d757a237c88f6caf2795351f302f8f807b32e0f95f1f6172cb2692bfc2199fd063b9ae4978a453b82584ab65dbbeb173dbc782b34d033", + "4a3c65defcef776c7c16a7491a1efc491282f7e3a6a9daded0b62e28237782dc793ef70a7e538d07dac1bfa6e4276f565b266c5ec725f6d181f336dc3d27abeac6d6053ec595827171e14576e137887d6378faf9d96212b9718d16126f1f0f03899e23eb0cc5b55b3cc994da3dba1399acada0a122f5cf23c2a9f7ffaf775bc607e07a0b077526c2d422a9e803518187cd82f664cb241c6be278ae933820573e0249fe484b94f7f5c880100a8736dd0935931efad94c20d1a565de3ff84bc87829b64ac113c8d31ae0cb8c4fd7a40941cf6def34a70933f05f31cc8a08ce6f3125c46ab4485e04a39303b126bb786d7dc69b8b55a50d401d4e0c412b0e236f02", + "94b1231b3194c6db0a3524af665b1763574f82b7e511b814104e3ae06b64e828930d7cd6fe83bdaa47977a93a52c018169d22d9bb36320f750ccde2dfd77de5e044c831e3397107e13ba0cb0ec26efc8a4846c20db1d602f86341271a435c23338ce3f71db6c59030f4e446ae9ada4299c0677e303bbd9241f1ed43e9b0a4f76f56b44ed4584bf70b0ae4b3abb87be4d49ab029feeea823594a7c4ae323428000f08b2c70bf67ebc13ba895c0330fb01e4218b8b827b31fee4ca6d0f5cf35d8d562df4c44c3b731b5823cda7f461c7e1914d1c60e650dc900a422540b547aff3f71b837c7d10f71ad343c3a1295bf40948d0dbbd3561eca0bdd88f8e35752275", + "897c580fe218187e8088e090d1cf3c3c771d14013ffb6ae96e9410e434b335cf6d500734ff93671be93b001472309dfe6161400e39d35aee618682a219070fdfd2f0011dea8b9b2e4872d0c4a4e9265eebd3fd3932c83632b57e1fab618fd233c071bfeba7757e58ff9161a34bff354520130b3fa071cf6a21da7141d7772b41a80fc16c14c2544c236fc771a16bbd0a852185f76f96094f0e8d409fdac624bf2a4a59a1f30c3fe7874889be1e3f95217ad85e1f5afed35d35d055e027c7149a6d903e9da77963b408b95f799441b736a785891c620ae28b7217854a306f116732b3d0512621d640fc6ad45febf8edf194b290b332f45db3455c49dce244c45d", + "18ac45aa28882ba28577428bdb23599899a59dcc806add2a3c06d36e5ef8ee950f3accb85211d06537b6df5e9a79e146079cca55ab7fc11cb152c5aad5831627ce7f96520059f08ddb0c8f7995b02ad6df64944cc99a24eed9afbfbf7d9fe28502398aff9490c161affd285469afde3815f39027998e401db219d0b96f24424cc538473be2c4af16cae7188a494edb9c2781fdc8691cefdcab73af7c536d22cbac494b88ebe18b26bb2097f9cfff78e1657625f9ffb5cc772ee703365cb3d8e0447af5742536ab99726936939fae57e62ed5d480caf25b2742c84d43481352015603f8f38a4a1746b2094b921de172460387ab0bbcb1ec6b451b59164ab2b580", + "80d38b812ec9f23683a93df90654eda0a4aa1e49c1816026e8363292738b180e247ef54085b02f772b31c41b422db220fc7e99312ea4ac09f1e030cdf731cae86215777b7b98f689505f851e322bf200d691466bdc60414a07358cb4147149e59c4a467f8585c0825089905339955a01aaa67b7ce0f31191ca533faf610ceba1face6833b56e9bb70f91bd7466a9d03dd2db6e634d35cdd9519fdf7c431101d746de7e6744e39be7cd41b7def33d2d51a77799657d3c46462ea2b5991b346576712ce1dd900857897f00d7e974aec29176b34a7d71430f7b99b82de87f8d6a3c00f2dd1f5b1986ed19d0c3b4d7733cede0c8ecb577fa39069c40b3956563e3be", + "bafba45f16efffce33df2f7a3624f4ddb4af45ff883efff9b56b5f2e2d2210cec997727067a67b25244aaed77d254cf4173d2a8c3e5eef251cbb011a9e5d6a9db232e7ceb048913499a71346af3a82b9ef220e9cf0fa37ffb42e11a9653c3d3d985c6db6d4e2918040fa4d3ce5925e06da2dec7492c938e59cbcb3495b8ced9e8155ff3d9bd3143491f7fe1a80bb7b077010738b21e8acdd142cc3e980ba521b0b61e0869b18cd463f33ee8ac10b92118f8ea2a8ce2d78b2417ad6aae6887338e3200649e96eaa4fc5bc43998a1000f4e7204f58eb1296447f1835e4187800eae3bcdc64fded4f57380648d719896ebb1349059a52cee2fafb02135741055ac6", + "7939227a2fe827d342f49afc3431fb3424d3ed614dfcb4bd5834f701e3ff61b4c552059ed0ed05e2f416f6db612835c4d9ddc08c4b21d6c2f2c0e0cc0244be3896d45a9ad1f2486f36c4c60b3be148fb5bb0ed59865ef39037d66e386d0f4a8524b7c137ad23992eb534918302ad118b67a130bef00fa56ea4a554bd855be51f5957084c42b12495a7ecc5c9ee9140a6bdfbf813cdc30684d953f377f7c4965d4de187e6bd4152dda490ce7862762561fbb05bf73e777c002ca0b17701f6205edf37ec2aa75529b7a360c3d6ff4dc5330bd638d4047649bb0c03b660ed30deb3f47f03b7541242cb515964aa7704032c6f4e7826a8fe4c6f3e4a7a1d2a98a87b", + "37fa790f8c4a359dbfd9bcec49840af23870c267919ebb09b5e4beecbb30b89179b01a764d10838066f8580c6419e2aacb7ddb57908b697686c6dd12cf2e5e7782e00948e7bed2fdd5f18205c0e10317189189abf16fe27e465229e6611dafe6b2ddc2596a52cd9a0393b814416f730f6a0c12d26bdcbf6aea18cf8b53198d336289eab189909fadfb130a64a96dbfbf68cd2a372adc19c54a641f494c982df22d53704a0e65ec81e05d7e6d0c7cdd56d34e142b6d035bd7eb59cd8b2f37dbaab93b72ab4a87be66876a8b46ab346dead679dd26cf3b4dd498cb8b6add55700f2667eed6647272876a4acc47679b23bda7d2acfa2dfc0cedd4234d13f0fd7d65", + "c278be3656ab41ce348ce4fbb549abbaf088f179994f90ff81d3ba25b2308a90a187242f184dc5c79f5a3a6d2813e76bcb23f7895d28271db1ad89a5477bc7e73631ca5e0cb7de929f8c3eff03590cea732f3c2553319ee1d6a62b87c48949c8646da75973074cd14e6458c9ebfaff7d3e4b9493c12ff7b320c43cd7b35cbf4da2a229c1e639810b90c1ded820817338e945974804cb2703de4cb02ec979c093b9b67bfc01688727eb6be651f2e2480804648d2a0f34aabd793cb267196176a74e8541b4b07f2ff39c68b325de2d28bd397165009ac498f6b980fd2ede06df2ba721d94270090465b2824e0a1ed6c800ec47831c1454e2f38005e83b75b371b9", + "31296d5bf39ca9b895fe2e4ee658756d8f08f8bab5644b1124983a151133469cb2f7bef79f75ac47e9f4d73a4b0a1da8a88882062d4594e80804947866b0d2fca587ab5047e9f95205f9a7ed5968e3e685cb9a663e9a5f9597b92b156fba34b89c0f41d77cc090dba27442f194d2319986f581eea1e1f2b4ec769a6fa8ffadb911ac0fcfda809495171184ee225ac8753c3c2336e4f07a529ba89471abe1dca8125a73e880e3e79a30882b313cb69a1ebb6dee4bfad3a82a16a78d4f52460d3a93fdff7d2efeafefcb5232954dfcdec26e07b018b23bebcebabcc2bf56c8d114ed136ade8869428e8554930da8464d1d06038f09c5f4d34376b51eb8dec6f3e1", + "85b2cfc4c5c708cd90f749a645fd48ab46020b7fed00cc26108ccf09bb625d825787a6672048f748630f4a495b7add68dba350c1a17c852c8c61797135eeac9cf9526c5631e9ec69d179f9781dded8f4d78ab81dd423835d28bda77bfc309166ac32abc7f268c0ea4aa0a65ca48c7497847cee4fc40007df5c4c54a06e0890a2d21796d32eac5436996afaf4d8615a4b9ce9e4d8d5cd60809e050feefd307c07c2ddc94a97801d908416d561fa93e26491788916193e84a41b24a79ba6040626ca7dbdb98e67e5db0b5148115e64f367da97ee4db5f48db7384ed44d674cfa32ce693fc29d416d7b4e557dc8dc0586193f16fb74b03a29936c107e916eff4518", + "7de3f70faa5a2ff96e944dc5a68faef2dfaedb522d5f8e10abf14bd2511dc4e8f94f7f26723706287bbf2c941dbdc80a116b1085cbb17fc2c3f2ef6e39d002f6672eead02612053972ba1044ef472360f48b0833cd3b1a3db7a3fb0171f091c04a41c956e78e1fa0273a902fc42c26d3db0245cea99ad3ddea03c73fc13b827e07675979cc45080c82726808ef38f64e8bd92d299ec6d9fb5f30f0d991d2119fbf33b3942aeabe9e049ee46f41b723ed0dc4f07710d9f35823227cbaa541c5c2c44201a180397a4bd1a632bb87bba6fa2893ec034188e6e79ce11f8dd5be3e28ccd8275e38c55dda4e70fa91be4b67b094bc3ec05f3085e297a5684000a31984", + "a99504e780d0c8113d7ce102d98f5107c8bfbc4a2a67936980ef53f085b7878c0e0ddbdf3254e58d9345645c9b50c09e0cd6ec6f3dcf24f1f9f67c97e04c8eecff73b4a79d9cfe945df798a80d4c518e092a9727b92b85445dae5240b6d358a7754981ba37e45733aa0d3abc15577560483b90ba507f88daae192d1f48e379026b15c59978b59ce963d0b5261aba25cca74b0b21f88b1e0485ba91c252c9e11f215f3cee0d34cfc206577888372c6b155f50bfdf4a4a851c3e7598076a3ca2d6ae53aed31b164c8c88a2718d586a8ffae619abca4e641c82050bc4e5e4b30d736a1107337c7164f39e4c6c9973ccab7f6b1e2fe0e72ada790da32206630ec6dd", + "1c13701ef521792e207675cfa124cdad36030bda5a6d8fe3c1a0ba34c0e674c795fdef291ab804cb2eb8aa6119169ed9667611e6c2635991955001799e39b970417a771320ac1d9eb5416768c91340d4aafb9d08230837dcc27af8e3e6d26ad9d74c6a066f1fbc502141a2bb389ac730fc6e6821792046a7f17c035da78c1b65d8d034894a8e7c6322ce98a975aad09d6c0f232d1a0c31ceb3469d745db21946007dbce19a26cccfc0071f78d20af8a333e36d72ce1469d75dcb3802d3248d70bc89db9d97da55fd3f1c3f4f0693539182b01e9e5cfd677569146767117385d3de97b8131dd27c5115502eea2c560cd1c1417fec0facc03b926c80387ca3f931", + "173549ed0b1ccd788283eec7b6373bacac1f6d52a0b7ae1979c175f8e0e905f2112e0a06ac76751748ae50f5ddc8ee1e10c54f91003de1c05699d74d39e4d83bcea9fba9494372c8b46fefaaa67c683eee2021d35a089ad853ede5b36a498b97fa0e17e29b6fe889672fb5c7f8b4733b17aad05746da0787a31e3524d0e5ac0d176974613bd502073bdc0735790cfc2fd561136a2ef5b7fd9c1ebbe47f02c150ac433c5c8d48d44115a5726446f572a65327cbd19fad010f409528f79e8c6135110f9ba2d7e219db51538f0e1d08fcb5fa55dc6bdd3c0c632f98c2474b80a220616873e338c1949c10fb68ac817fea7d7845b86c4c5acc1141d1c4bea459b5e9", + "d88e1a3abc16081130db01e6e5bce502549701c03530c12d069a951c4683232674d4db26fd52341ce466a814cc6d4e4c09214e05a8c2d165ee4813c793d00afa0db6c6a9b53bd63b142925b94a12864046cccc817e205f79ef4f93f6d60c43d5b48923f9398383ed590ee84b5f64bd638c9cd19d3b568423bd56b036d090e42306aef83f920ec3da13f81f4793e33bfad1b8b01d53b2418856f51679a03dc83df9d20c573f9d224510765690631e0b7d3b21e7da7fcf5d07f7d6e222f205fb698757db581e99c0dd456da884a661d69a6e4a0006297b3e31072cb19af0c33ab71b99db523ed7b3475d82eaeed2eb4de6e87279551ec8e68a714ee13e4a361697", + "986d407a02cc3db6ed0569a6ede8b46e7ca6eecac3c22f6181ee66216ad95904bf2c02a22bf347f0a99637926db4d81cd4d7374194ae7402f237101bccbc6267578101b2108b3e7c2cf72462ba740b3f48d681bd0aa2e08eeadd0538371ac5ad32266bc1bcbab94082ad9c7717156ef693864218abb39e73807fdf239565138ffea0c2c8082431b19826812c4e9374083d22becf8ab4682f05df632671f28800684cff912381edefe45a5d2111874fda96762c0fb12870d2dae219a1786e9f4b3a5a32c611ec913a8abc514e10f8fb280583a573a784c7b063ec209f031b7d24252fec86c05eab0c01b728c26ba484322342d9fdc383f45eb20281282abddd04", + "1c6a42552e69789cba2db4fc848ed5e2ae9a8f01bfca8806acab5e9177c1c399b475e0e86ccf4494515381f593d4d2c5f377d25fea2c70c6cbc7e98cb2708c9bea0b546feef9932737d163172fe65f9e288523ddec88ddecad62f77df06022f22759d672ce8bd1726d83c1246c5890499e4ae7d890b68d5310896fc313ffbdede2e6845f6afa9127d9e6045cc95dd3a117473a546c04f3b181608b50a2dbb74727fd0004db198132c84e24068357de4a30d1f25653d178b01d16b51e238d4ba05f90abb5388af14bc1f72d9c8b5acd0f130743d3931f626f64e6411a04da8667683e7cbe9ae6c4411df1e5056621d02fbf72cfdec4b3da1b58d37cf5130bf1e2", + "93ab843731d858cbe8216f252af570513961cc8f10ed49073c7376e64d25cd0232fa08a53d0e61d16781d51f26505975277df0711b4936cf308845b6b9e5c4254e21f3b4023d2274dea249a8428c3eb77ec355c12582441dbde42e0c7d6f5d0bbac66a13091203fa5d6bdcfaa02f77d68ceb478e141d0a78ebd917fa2a698908c713c9f03dc8e7ea01d40da46089ed589052171d7695830c280fc4a99cd911e49db9613c9d5144279ea2e500a80b667a9dc8a6fccce8913298b8e3ecd259b30987a2d4740e643f4926887abf0c03d803c890d12b5779f5f7a37cf6bc6fea179bee1badda6199e707ffb63c0679734fcaf9753c4769fcf1a7dc69cbc71dc321a7", + "a096fd54a6349584cbdf2ca314792e76bf8af59efc90770a684ecf6e42d6f1741f0bb8e1eef87819395862b2385b0edf98afc6c261d3904e9b8e6359dfacfb24eca0105f8db3b5d261ddc64eea1b78a5b994b28c2062071f9525bf0ba07a1288566c4b1ebf876e8f5d3e8a34aee9dce8ed86cde3c97f5aabf4a0f0daa204fcb39c5d8aea29e93203aa276ae99e6292870757598f2bc342386a426eb4e6e7a26bed1147074751f63de1d475b6c8fcda4c4f049c695d634fe7027e4a5ea30329f67ece7244dad99949cca35cd99f8e3eae93b32a1fe7f976257ae428a3c3e20cc81a8eaee3e1e316211345c63b18304f32770036aa01f5e4f5803cd2b5a8533016", + "3cfc801f8f0a5aaccef9ce0d5283c6d368cde02833ecbc06ada85a60d01bfd4ae466cb49f07cbd6ca162b5c52be83f361a79a1e21f8c8ec6fd60fc788a656bbd4b1511f15f6fbb87266089b7e48b08da361dcb51f5b25bf3026b467c851ccc50f715afa9733557f3d2286a59745e4a3640ec15da5c9b1c67ea2cf8f236e83f953db68193cb70238a5bfafdf8999f516ef3b654cc403670d17560d8111d739e43c13c70e9a34d5380df46f2dae52b589daab025a78c292e1e856d5a183df4fdbab2154ffa2a582f6098139fe27bb940aaa9bdb0241254b7b0b7c6ff44272e8426edbebb694bb6d6e77c578aa0b68b46eca29f2f43403e2e9907c3019a354451e6", + "ba26268dad4d97f14b36dc6c8da595c727c9001adc4fbafb1d24f78adccb5609135133c48dc5f4e14755a2506b4169ec7be5bc17649ba50ed17f8e2199d467f8b8c80269e8e16095fc7e616b480caf6da697cf2a7e019318a3742298d6e4ec33ba3a8c5cf79865d2a58508581404eef48559cec7299c20d0554c65409604a66aa3de72263895d14600cda9215a2afb4a856181f0b0d654a8d2f37c7b4eb4c4f82bec1ef742917004e893d53463bee8ed949667f5bf95a55c55e7fc2ac1291b19fb8ca5785d7a9084e61cbd4e8ea4bd77c13509ec152553016faa6899c4ed2e6349465c5ffdf0ae2efdc9e3d3cc552d2b16391f6ef46de811782cf2f2e13e7128", + "532d414b271845a9e8f10ab8827ad28498c243aacb9bdf2e597e09718de180fd08860ae6f2cd300d72d01faf3247e7d604bbdc856310f4d5563047364328714dab87071b5441ad33851ed61da1470c60ed1a92e6cdcac58209444dff1dd39216261103d6cf5922445455d22c71c86a5618930debc903e73dfad71bd75225c068586cc3a14061b1ac47fc05fdb6d3c0646ae804df35f3abcd022acd1e8c3ac31957930d69464a8ea5e596cad0444876a36c49e655749cf1e95d8ff6cc577dc5f8c65bcfc7d119242756f1b270210070684de4e8d09cb39d4525d7b11c06b74f99388157d4f8cb4f930c77c31ca4718f98d65bcd21db1c98d7e6820e7d4779aac5", + "7bc4e234ed10714b3dcb232a3def45a206334bf0d93aa220c50cf7ba8edef81d2c618e4e4d14ecbc7b3bf8af83690946338ac05833a2ec4543d2749c26dfa0b74d9c9ac6ade68db8696dd7d511766c98d7637d53cdce10ec36c92cd3a991eb7c3e558e602b6471335de3dd6075d0e8c5b4706e022ea9663725fd0573099b501f750808b2c2c6c4a8a4b5c461e55bf14da3ccbada4923016c3b6cb750288cc17fd225ca741bc50a7a3ff3144a7fe47450f569658553dc510d9b0c9e379e9a015c2cacf90ff4458f3ef73ba1d883c544c1c6a713f70da1622c19146100f7deddb57ce2ac82f02a992b43fdc412b60d8c6523efc552bda4a25853a0fad0e4fd5503", + "841839578d7a7b7109935ca0f45837a921bf1a1e9a829ec0edc144d8d9c92a045bd8220dd5044307b814519acbb88eef90c64bd7b3527231cf223310bf58f866ef73dbf5f2e77dbbcca5e522fe72aede855cd677d4fe035d522d41dc9da3c1db4fd2976e3363d5efe7742a25b872a12c8230d8cfa1336074ab4016fa0960f65d9541ec7448550af7b125addf95bea1e53a26168fa613dc951a03988047e14bb7c95bc8513a81c6b2b46bf524b93612d98780091ddbe88fcda9b477788332a7982a0dc6ba8216b2958e00b3cca79797494fafbe2dd54c9416d9be4fa80283408fe4371148a297f16985c9ac22be4758eca48e5869aff769029a10886da6ab2145", + "c75075d19a4563b826aceb1d87f878d85d002db36d5b39c384467d0cbaf7cad39dc2ddb1785721db0101fddad5334569e3f3a585f7975cd60c3e647cfd074088411f50615fe15ea759ec0d58d0c51aafcbbcf6d0885ffc60519a63298e0961cdf9e9ec4fc495c04c31a87c44acd5ff766330a47fe370310320e92fe51a5e805f262e244b80966bb18cc2100baf634a9ab7ddd95f4332a1ce4596552126ce4d700861713dfd1a078a3e0abdce051e33c6356f9b4d0434921b52a12890f2c2b0308d6241605cb24676b447ba65ab8cafc46a45628f1aade26c09a8d6b73510abd2184a1ebcd5a9a4bbbfa71e213dc47136e791c5c19199573352cd7b3b4799af68", + "7eb7b038a9c4d2a9b7d9e8201061043749426fa380a1e15ba7ba7f9e61df2f732fda3ef062d040865f912089a66a64f3e0f589a5d11237677b0350304c5c98d2f4289b595fa41058e8233fc9ab4a8328fec712dd136688adbc549a31d78c31afc79cce53969f261a68b6ca02a3a0ecfff9ca7e386ba9ccad146062278a06c04fc9587610f17acc2490434fe1f8e987a23279cdfd2a44bc0cb0cb0bd8c528fd47e830d50ad3fac40408bd8ad447e3a76a8659df0ba6b6827475ac46e705572b28ce687fa9903c8e131680dcf1e83647b5f5ff4a9f4c01e082308b55038b4f4f9b2703e756277ac0016b83026c02ad6871795e0aeead5ad08eb9ab1149514352f9", + "1553dd341fd828f6245c5a0de9cd5526ccd0289cb5087c5918f8dffc0aeb65e9adf57880cef2f1397521d68e417198d5b71b01328f6e8b35267cb008e8d4b0931bcd10f5f682197beae30e79e7efe259db3f2316e304769d67fe2d09b93ff1f00b1b2860e10126efe0e57627717580d290e3da8bbe25e80f24f6e1ce2ab95cc8a8f32120abd897fd081749d1b67ae52c222905f332cc11a4e7129d522dae3ca135d8ed2076d6522fd809c9e52bfdeb06cf1fb30c3405ed84eaadf2ba90e93cc7f80d0dc67a332e2f924b229e3db3db8002d886b12450766268633d68d4f8866e60bc0f8da705101d7734c4986cac19df0a148e992a8ee65efeb4d3340fb35fe0", + "6d99dbe49b31fff12a4eda7c28ce55f9521b65ddfdd0f1f8eea7c0a16ac3c488f70c07204aca042ae82aad3a8772d283e7095790dbf7d29ca7a77cc085a7032f00d9512a82c0aac99dac02648b0a90e800d849b425b93b26c7d63723690c6f2b79ffd4176384ee207a79fd4e9a9ab1afde6283f8c5ee6c97d0ec6185a73895e3e9b76540dc5cc72f4946780f70fbb27b11a8bb89f958a006254a9ce2234644f7b5c3e7047937a9505c477ad732b756d79db2d4cf94a0fc130b6ceee7627e7c2c956fcfcd1d8d857cde3151e2def67df1372c886c8633071a523581955ced9c2f40e061e49b1ca7f8c6c39b88ccd4909cd458a54688d15dd31aa8a2927e55517", + "549feb85d76c9c9c5fe2e3aac729472555d4e1179d3d83e69ee3bd0538204cdb9b7955047df593ae58ff8d5e9fee3f31e4e066752347a9bdbdab9e6ecadd6fcbb879071092f85ad306f03015bf0a0d22e80dea0539b70cc1f4391973f786daee48c0bbfe17b0de7af78a9d1d20095151794da85542fb6c6353465e3c3a71266ce3c592e6ee04720d979f6da6690904329410e7fc0adc5c94c7411595d057502afeeef683f29a171029472d726915c6d5e18cb69fa2a0d20c3e9b80f21254b0c9a3bd5e31e6e10f28f37ac0dd6d3bb681e5c3d0a5c4265bb05bede0d3044cde3e3b75ee4078f616c5975009608bcb915b3b21a1c1ee9d59cae81ec0bf23f7eeb", + "ca530635d30e34e0c25911009625b537aee5b8f85e9b7b831174102fe597cdec3cdd058b4c6c0d955676e2526de1cb01722293ac426d9f5207ce8917ce78fdd507505d68abe3ae5081647ba520a104359b3748a3246a1fe010911dfcc23da07c7ac87b8c70d752ab32e77c06907aaceeffb6faf66712ba02f12ebe43b9afab53568aa151eca87a8f5175c71a810086da134632d35796d2052c8b1700e8c5420f4b1abbf85ba982608d90fa4050bafbba645571ea04d2b21e86df73feceaf1bd4ceedee4132cce5e2d466802a98c58ef6455f6b8efeaf262f622254fe9ca08ccfe631b05bfbafd89c28eeb4e812ff84cf70cf943875e493cf72627cb5d0cfa4e3", + "39c366dd392949e433f361966094b1ae10f042496ab0a6b261c536c69e253e44010ec75d25d94a50c91d4fc9471326d77b318528345c9b695ebf7b84b0d95189fb7b7223c1859973e59b381db8a8f892642a5461e0852f92dabe030d566cfc1a49b42de97b4d78b7f2da9196f593d533298324f617e1c69f2e5c87ae974c25135af0ba33740236142621deafa7794ba8d327fb5e305a7f87d0f1e6de06135347a76fae736e9b717ee50c43b536542ab0ed4ac967cffb720fddd91746c9f5768af1e103bfd476d9f84003d3dd475b425366331720e43cc4a216fd33b511da526d46bafd3ce7f7d936ce5cb1026040314241c4fd2a4a9bae3d5b3a3ca51ce15619", + "2aaadc3f21ab993b4302fa2e7c90c0e729298c066a450f5321e1a83f9032456add34e0dc77ecbef7b5445f0a9b5e683bd96938119bacb841141bbc62052c82bd85f8cbc95e76a98596a5b6b52feead0da98ae3759214341c34260aee4b6cd9fa74c9062e6ca409ebf8151aa43eae09477c2ab51083b42b41f1e9da713db7e359be8a998f62ab4b801f37293374f13bb653a32327493a80ce4279c9eb444a0466e8906cfd9cfe83f9df4d6f8aa87161ad5c2103ea59939d09fa12884b5db8c5437700ed303939c5ccc7c7edfe8f89e18b9b9212ec4d22d1d8dce6ce9b95c95c9ff92f1ecc63bb412738bf2dd6c456810e66a742889011ef1cb99a19f2ea7018ab", + "1d85bc1e9894409c49bd2e3a77d36d589555e167770334faec40ab07623fa9972732800cb354cf1ea50f333b655d576649efdb2fa46d2912f7ff4fae8b8655bcdcebf0d9a02abf893bf805f5dca248a36b7cd84c261eb0fb76f1ef3b81476fb4fc63c31d51d863ed1a8bef6a5858645540d5bca9885c0bff3ece13adbb58bbfb99e3c13b20577abcb4bb636a4d7c6444f1a53d05139c9fa9eab2fd1896a5f2931e1d513ba3cf31387e3ede0cf25963e583d1450c02a0086d8518cac3b8eab5745ba03ea80f1d286157f03094f9810b58c7ca72975db213d163bd95da390d70e84631ecd15e8d82dfa998b27609d825070ff046e111055c56976ee37684bd67bb", + "98e67791047de49e8f4c36624affc1e4cf1ee6367b3efb4137ac8390e256886811502bbf68f2bfbe378af6f7ab879cc7f1d445eada783a191a29fca2357ec3d5195af91d37fdcacce18d87d6bc8387d42b9479694c3614651d3571cd286ca4ffd4ae55e1e7d5d3a1c6ca79cccf6c636afd905d8c88f3640e29fc05b963c0ba95b9c709b4d6dea7e1c04070bcc0581bc4cc2eedd4f68b860453afc54dd8560a66b1671d093e9bec2a308b9af2bc097c0585b8bdafeaa36c18c07c77bb68f329e4e807830d951ca5fd8689fc2db5548ba6d29266d344d5374a3a19c8a0ac1b0ea3c4c1d0a604003cab8276f29a66c1a5a260f9cd444502a2a9e887bac3face8e09", + "d37270191d578bfa8a2e632dd1991cf47093d2a0a86d724944a3b5c970b2cdc050bae30f697b1d20ad9a3ef1a35f3c50c6e4236fc4b0d915284eff8f67c96abf973c20c714bbf5b90d2fee6e0d394220961abf7ec112b4751cdb14c3428187fa3509b98a2cc3710e23d6a24e47ff4766b9e498cb74ea0d30eba62d46a44f0de75d11185a7fec65331b3dd815f4a8c3fb973dab09ac9bff2c90386a4b7b38c6f8d4815d62953ca091b41ce49973d2c8a530facf69ae8cecbdf621a9560f39efa58b65e2d631c19522649703d9ce99a49683914b8a3e3169d79f38d590a0a67a4dc36ea07031e07851318e0e54700f0f88f09c8a16e9cacc4ae4d09276bb691979", + "b523c5e7470147a96d966ef8d85f4896fa1153433cdcb5e62313a11eaccf1a5030f53e4e1bf6975a99d00b46bd09a332031ab9054420230237319ab78f616d4211e81bff9eab4eeb0f0830128440ee50b26b5b9637a268d8862b1e5da9106f2733b6af1470fac3a0b61e3262c60f9c9256a8dedc27379614187d5bb4a9d88cfa2902b19023c065d3c17d5d4cf94787b0de1e10ae092e9859add97290d407384dde961d9757b30e86d8170c3e00da8dfd761fdce4a4756e5e703494cb473681347f56e9302dd0102c99bb690686b957e070318cf5936c1bc5b8d8de7e5b8cdb54cb780acfefd09cb32042a0d593ef1af2cbe2d05eb5c0c852a5e5405a7388c192", + "cf7cc07551f3520df9f3b9095636dc7f344ed840c7195be2ba93b1728e4085c0f3b71a5a2576ba97a8e9309b68d2f3a0a1a97a97a6658322d8164c2ee0df3bb3b379939751f481b19f46bfb0372b2ecf05eb485393e23e965f8ebda7420cab3d352e99ac236c919916163e4d6414dddf69702c5f307e906219e8f64505029f587ac605485060c0d16d8cb15d14a5734f119d81d118fd6b21f1a280d4407d07d55030b7a8ec5014d082dca040858a9cd957261f715dfd848d6745aa5efdc6f62db1cc4ef682de5d9ea237145394aab24bd1fd31a0b80a431ea0d8d8c8307b5c4bf64330f18b2296673f05371227468deee83762507d4bce0c8c9b8789f55ec1b", + "811b46122f6e6e2e3fef5000c991e4fd7342c260cdaf691842ea6ee1f1ccfbf1c083513aa9b751020323f2c9a948ebec2ddf5be8bfb32f255b09742ff09a85dfbf06f4f037839d538509ba5afbff1fd9d1a790647654ead35cf42dc67a9d98341ae0bb0e5a172fb7726288e0b29dda25b7b42b6aef0077a5d2053000f7ea2228b454ad500422e9545166234a1495e5f8cb3094e68f965263bd74aa48b9224924db1bbacbd912ab87faa360cc2ca86ec72f286d0a8b05bcda8f217b11e6bc758e8dc43f567b8fccad7a1668e24706910e4d7b5dc85ebac32065c891f531051576470ef619ab306530424d3456273999499ddf6740c4e45bfbc907853daf601d62", + "243d79f3ee641ece2d20bfd730c602af4d18be786e6e603f01fca85475feaea32e9b8470aa1d8f12f5fcef4ef462b412498dd825c52b3497dfbf4d226eb3665267ddb70fb9567827ed6bab4f8c7d6546e7d4cbbe79a6ddff4c773c32934493318cc0be8417bb2a3b348edbd71bc8e311c8fae13daa3ab8b8b4e0d039ac36e8d003552a14396971e0abb54142fd9345dc5fde3e89ee0dfad39e314150c9d95f6c04b54b88751ad427e30d27f89816bdcc2b42e662cf8742945e9833f3cca09549f010bf43f5ea53362ea84574c50185575da283845f52f872d5ee0686f50998e625541f446a851ce256685cafb7374b3d01d20ad49b890414cc12481b5c4cd93b", + "4dbd878e0d8e8d1c6e8f60d478bc38da3e8ea9b4bcaa4cfbc30e567eada66fa7ede2f9e5b689088e60dfc4edb09ccb028314d7ea04d2c272cd6f16ccbdb5a2df9bc3f48ac1b1ca64159399ff2dc9d14f194da75bde3778c4c8b777840cc9aab3ded0ee3517b5d5de56f444bf3b5524beed4c07d68e2feacacdd4a9a13f94eb380b672a68f566f4b2d0060270c53d118df313a52b9fa40227cb523e82356a67c773ac1a526770c706a1834d03d33aab71d2fbde7903cde88b04fdd0bb9214aac0faf3ea7055a01ddb936040807e12a6ff1802f6fdab869bd0e490b4e9a25a82739658cb5065dd4f9092c8d0101be1d99fbd7a0920093603f7894820be05831de4", + "8b275b60908ef5d2bb63af6606dc32031856fe6ef764d9583d077bc5dfde26faa83bd16ac01f6ffbe2adf736499184d34e4a93a5d0285cb6a5ea27fffba130294cefb502e995a7396eb3ec022df9255ce37c9e2bcfdb7051d4e80178c9e520fa45b55fb0a01f5cf61921c51418debaafbdd97577c6438b9c37ed7e0433bd4405406f55b92e5662e66a89c393b529b3ff309ebb13b6351192857578bc5cfa229e69a8211c69f0c86e7dcd907a6375a325976dcd8442b9e894ca074c5f682395032dc7bda8ab3a0bac4eb4157cdba6bf2d5f42bc3a01488f1d78cb1e02a2a67f62f00be76ed8f173c3609760c9a3484c129624dd4df2afbf0269f14e073ba1bc4d", + "c05b7807205a7e9d5b2ad3a8a14e20a020a5f33618018def6a09608ed98d470583a0f56bf9d57f82b341c2a7c0a7f0bf5376cd551cac64e38564dfd245fcb9016e47a1c787d17d20e213ea8a7574744db580ae6badef08869a182dbdb32a2c660a1aa1eb800fd2604c8b5da389222b9af92808ddc91a1e56707fc5341f0295502f707254f9a5ff3c1fef479e9099672c88c2e600b1bb26fa78ce746ed888305e0a2767463f46835df0f63978ebf3f4ecf60f422d87a48a40e8c4f1e1bf7e1a5300906037cb2b99e41f7fd4e1fad91fbc331a4be59400c6f2f5082860d57ad32137b562c535bd97d0f524269a803683fb8e0706843954d4b2c37222310bdf375a", + "8b2679f3a22fbf3c88495ba45dd4b7a40119598b5e6be81ddc8543ca716912efeff5e25a7299c7838f3e31cafa19f5b69ad9d3b1ec4a51f254d3809904565bb8b3f3cc0509941aacd736493a3a4272e934c03d5599683fc16152a10872e0937ba5a7bcc70428e93857244958a6bd0a5e556d963038219c6e9626f98c6c23460ce9bc26a13da8bcaf82d345e04bee602852d57e257976a9cfbb5c957982cd3ffc2270fa190219a5501695c074bcae0e60d89b52993f3cfd1a548543479be614f6097f668171bb7a9a95ae0ad880bf0ae4347aae14688d650d1b0fa494a2942fd377d05755d68bcd36467878e2a54497aa4ab97facac0314628b8dc2c5142d62e7", + "6375a832082a033702e44cd6f73fc8fef5199e38c14cbd481d1141045cbbfa638c833b3aef6c5745052b77d84b0aa382f88dfa810f4f5c10aef08daaea292421bc6277715c921066b554c23f04d728d5efd790c0eb3fc612cbc6b3d3eb1f518d9f1efd64c4757570faa4df55f7da9d50aec85cd8d5e1538bbc507b8eca0b33dc872592b8e6394f49b4cbc9ec428408d0faeef660bd06eed914d6755e2fae08657a4f2ad68a63dc9b3bdc28e1b34b43482c90abda1b71b1027796a8babd579f1387d2b66105fa2388e627932fe306cd923ae7bf909c2969632ba49695c5cb27c8096e4c4a6834463179001159cd2b11d62357c63d2ff79889c94389f162b1b68b", + "3b5027f6445cdc19d35e12c4a7956d2e989571a32e5ac3955e11e1b5be60756cf0111cc7e8e5b6594f3e1cdd38735b25b2c6bacf4ca7e697211219efcbe9415b4ddb09c8b7e92ddee51ddc642b9d970629afddd373032d36c93edf8320645feb581e911115cfcabf748af417ef221dcb34550992ed039bef158aa08d24927d875fcdc4cd469f3ba25b10a9c961a754ee7f4862cef7829cdc4ea7cfb2d53eabd1dde5e5ee81590f8f05ab266c14df6e370ecb4669aea8216e2554e0aa6def54689fe52463bd09018145d71151d47008daa218327365eb4fe00bc94bf394d7f50e3d3589d5e5b7ff387330661a34c02a1b89c451c9db809a7a060a04cc7ecd278d", + "c27ab5b138aeabd9f17da364074638ed8642f5fe79c699b3accc6161f42ea63a10d7789cbfc911bc48835d43300674e99037f52b44b5bc8bfb4e948b031cc1b07a6c8926fdb8079c371383fbaf87886a2d08f7a8a723335f671e60226908817959bc362ec4a3155ba90b61ac952e3e0c0d0da6b55af284776f3f7e8b4f5ef45c633fb1919d088e13ca48e9ea126eeb2148fb5b9f27f3e2053ec6cd8e432b761a81624d039008bf7fbbba0594439882d11ceb4bd2a696a9c2cea852df9dfc5b21460a6cc900ce2b3b8d2e763fee5c41b42a5491dd479b75724d0a6f687d4d632ae0fbca313b57de741982a8d814992625086169a4c3669c5c76cb39f779c693f5", + "77cc4a704a52fc20863f06b84b69dba1c54e45b5fdf2b9bae81bb9044039eada8e0525b5ce448d74a37dbae430d1892b68249b848fef8c393d38b1e9b9e6445c5c35705ef4be48493576da042cfb9ab8ee6c20cf5faba102d134a6160b885c3e6049b68027a03e0c1013f608e2c4abffd294372ac7a6b9048df25d2ec9ac4d92e9ff9a18e3a97d9c38226c257a5dfb95dbda12978ae52f833a362d1ceafb0b553a031e9fd0c9cd8c41bce3eb84f125652bcdef88a3a8f284a5cf784a098604d5cbd13907aa6db0eb5ee6fdcd61a210531d55d6eaae07f5fe70ddaefda3df26c900eb778b455869ca008ccc89a56d59244ead89ef9b2a3b560caff67a2fd85847", + "34c4089a391848d81c0fecfc757f088f3e2841b3ef293cd52ae1c6f09920e33854bcff6bc0fa61a87f47ce0bf82efbfe5bfcf9848d60ea4cefe87ab5651b8860a10b361c173d1d790921722a29fbacfc1bdd5dbf4d82acface29d368ccaa83594bd25a77d35649a367884da9ccc1ed0f39fc6a0ab0731b1c011eece4d28f55f5b98fed551330b98b90737f11511d54d847fbf755402acb074334fe6c7efb2d417c2131d86d55f3f503b7839fca253d35ba8962848d25846603e0d0dee744d9175cfe62f812794dd19a9c1a0e20d2e0c4c663cb39ea6e33c1692143a690536669efe10e3d87942ba17f0cd5350d5b2737e61c5129d13b24f3c713b4018e1dc655", + "15ba72a5ffa66d21a2e1a114d33c760f6edaaa593aa189a508442bf553cab0ae60d7fc2b2a05302c5e2c7fdfd987cc13f7ab129e70e996c02f4f894d38d2c6d84b01181e533d3887acd337a10fe83ac4867fdbee95ef1c5b3e8bd3e7b86ba31b7a9ff53cffb237d7a03e4f17c21d81fe7d7360083615b86321272852749e946cae150a8a134652fd1be98493776617d2820e02ded6fa20a6535f10bee7c51e36e72821c8367a9f1ee6cef03663620cf9d3662cb741966eaebf395ad07617bf098d7116e36439fb6e41aac17b85885a5d0d21298cf0574ccd4b278143a4fad8c5f8a2d998d1e2791351c33cb90b86c8010036eaef7ee18b58a7af7a3b5796034", + "1eb81e0ce2ac395448ca28a6da23dea0ab2e1cc63fc8c1f8c556e11d8cb8d38125607e6b38dcdb77e4d9396bd9ae1c281744eacbc4ed5801f65f4d88d5820514422439b08ffdfca9f792bb5ccd8b8792b3f23349335d2eaad6f3e5a3f433454b0f82f39683a69ac676902dfa8474b82e614b5ccba3261acf3b02e2ff1d6652f32895ad0c9af29c39ae0c6501aa761885063fec81e566f6978f106eb2649523e40e3e4d11015b927da17b037c8f8be80a6bd10163a29dc4f110d0b22ac4f43107b10b5cee8ffba710f28dd5c1a21c9884c7c56c9f353fe2264ba8065fcb0591a2f63df893526048b5ab384b69ec221b6919d26fabf0675d06d7430531979d325e", + "63d387e3568b6703a67ccc15cf9187b51618341e7123c33814465d8c9ac96f2df14fc53ffa165b1c152de82a95d4e8560123c627c44177c1aed2bd20f9082c466337b8e38ab1aa8966a599b7dd86e4e1592dc3b4a6fd65d442ddf4bc4c7f9202e243b9e5ed5bf5b21c2264340106b0b21e108c12bbb0073dd4f5ed8e0f559c07b6b2bbfdd61e5e5a61e23a52837d20dd1927acf3299b0262ca0f3a0178b5a05345d9bf36eeae5f07286f767a319b991133a7b8f3845ca556f4219c4261cfba11c06a65e170227b494409b7ca73903affe56114d9ce0e48f0a19c32f76a4dc7f73073a06485ebc979cad0ceb22be79c5d84a2bb8cc32ad88372b3342d27c513c7", + "290e51343ebad190e01e052f27ac0ab84651bc85fa6875040d64eef0d54805f81bfce734639c387cca71b8de63c6cf82b143a03f6d1b312f45987d310324a05c1b2bbc1d261a2e5f779af1fe003493a4653ae9783fa5eaca5f48103e68c059cb3774e0ec62bda7220b7cead33c3848cd7cd52afcf55ff759124d77e42dcabc682e02cf28cf57cf2d75efca49030cf915b3a660550994067b4b9eb5ac447d98a0c282dd82da4a9ecb3ed261c61cd13b4c8ee8ccf47d1d4b8bb9c4153db95e7cd93527ad750fb4fc97614335e7ac59b1636c5acacd44efc91a6d3b9754b6fc29f9199723bedfde3f64264a99c72e797151efc0b1f4372a024e3c5889753678474f", + "d5c84c26b6c105a548c16e58ad779a7edc8ab40c50072029b93ecc40e0872f14b6c966b964f424fa69c60fa06266d9a2dc52bc73517dc19ac96b9ccee76423192637e8a0c69b25c93558a1dd724484673eb579276cf10a4f6c59be7ec54fe18d03b7bbe6c2281ef9bda1fdaf409f336080b92258f82d6748d9ec4847eb5bc2cfd5e4e0ad5933e32dce2620d5414f2d718c3e3830c7432cafe82d815c69137eaef5ed8bc88bbb867d41a9776e8387fdbea6b21fd34fda92db037ae6284f3d5141b7098cf0e930c8e26609b65659e28fff9e0e0e79b3909b0409936be1195e205a3a7cdedad1d708df61026fd086fb635a1b67592943639e4f55ee448000c65462", + "b69e37027ab0f49e5b2143b503585b26384ac702ca3abb18dd003cbde7d8cefa7a9374b4679e2cb91098e09544bae3a1594f720269bb59f1e906370274397e4db8ddc79cd7fdd4afc00f2e9406da036e49a2a9ab40e8144774ecbd4e73877d8fc224da3ab9351d54ea22e5c5c8ddc7672559540daaf0629805f586f93c07e3352e6f2ee7b9bee86438d6d35a842188a4ed41d6b775126761427dee757c39d61bf105244775b2e6cbba51b6037306e422cd00b6698a9cb124e87f45035f1f39870ee98cec027d18f91837a80ef738f953441add73f336461d74fe1b27cd7f27567399f41fbeffffcf1b2d6cf4f96bf315dcf5221b6768f475d0d1d9fb41ea0295", + "860f40b88b556fd4a230b4dbcb6e1a82c7d28561a153af8ca49d28e01c7c7ea3faa27b75767aa7fbb69275514e71462d84f606e001352b4fbc20d47ad134cbacda93af0f5faeb362643e8707799b0c82e356f168eb89a5900af2c58e32504f254ac3345bd0b5e08a31df525b873247b096b8b0b51da7d818f6489f6ac9227d6f800ef181ac89ee9214eb7719a51bb60edf4cc2651d05e9fb832b518d502e5bc9e49796a9d192f2ebc5427a0285d9ccb6498cec4279c5afab218ce507ee30c64c5930aef449a03d56a04bb341f1ed306584de90b81b29b2681b8ea4af384596ec97515b8e2edeea6a1dc417ca7faa0bbc2b5ae053a2ea42c7d8e57959f6ab300c", + "2742da4850bc59fd7de219540f93f4036af5bd6bfbceaaf6bad1083a07893390ead4048e6a6a6b1cebb2719ac809a6723680c7fd0fdca2b33065c95c1796a22ce264a34a17ab9638b0d3263e87c8fa690c1ad2e20688c0f654d6aeea578ca0d5ddb0e62873d6926d2fe784bfcd752dc393c6af2614162cbb7cbee7ac8c68c765c7bdadab4cc3777c263dde66aa3230921f99c96b73ac7d82e273a207f629eeb5ea701bd30fb8bf5479eee1c04dcf636faae0be427ff15612d08388ac1f275257cd9dd9dd1f8927a5861d2de9ed2231cc1cd524c1ff9a42c51e801342516e0e8b682ff71b2b9c83cdade74299a587c6620981bedfd0c04cd3fa600e24cabf39bc", + "8698bcae249a0cab2775d4fb2d22f290a51405b599f6197d5bb4512d11902daf7ba95a801f403f7b55218b36a547812b175b96cc7011c2c83af832abed33ef266c6c511d64d991760c80c3e1d357797f05add8724c494fc47764c43ee8f191df64393271a1dfa34842bc789a5f830b2a0a3e09e0b2a8aca241be8abd74f33b01f6f6db8a09be2c9ae1456e8db1eeee2925d9bb673639080436ff87c18b27a14baaa7798cb169fb968e610b401a29fc13e3e2a8642e8ee566b969a8e06983f1b5002cfdfac455ffea917d7cf38d5ef7e4792f525879947acbdfc886c3aeea80a92e583d4e2650ed2c868eca700914ed629b684abd2865a4adab960bb7fbe70f84", + "67b96731da350435bac5adbd5054269bab49e5c436ba066403d1f7e52767eed3af2b0abd7be337b735b3d8f3ce964bebbf209658b739dfd9b5551c4448459aed31363f18ab4ae5b94c4b14252338e9bf308503066ce3c7fdf3fcd81dc9e46018cf5221a60068256beba85a0f38af1d236fa665920b1cdfddb4d04ea402b4457c2472e13fc10bd01ce40e9763e2c57f7c63c295ab92f1b34b48ef1869aab7eb43e4054bb32ad346a8fb6ec45aaa78899eee93e8d93432fdbabbf8a17258d48857c768c6910c84f457e332cfa49a7c20c64d99355076ed610d179194d6b6691d72b1cef61e8934c1a69b55d7fa07c1dc1e5427c904f7ea8878e07cd47f5dea7e79", + "79223f7d3c9f4f3933b1cbd3506a9dad2eb092dea80ad32a43fe982aa6a8fde73a9000d867f700b2de7c59d43ab221fd864ea709dd8a0092a2b3009ab533914fcb2885eb9f6ed591ed197868d2e32c9d2cfa19e76733b704291273348b790e9297dc9dabee785fde55d9d9adb171d97b173fcdf22afcbb021c2f821072271ad3eb1483e38ce54062f06715d9595b01618b2b97a5ad6e50138a516cdd615ddb720c6a47505c6e8cbc3caca6182127e77b0627c4a1ce68a4a427b555625c5eeae5bae8aa892b0977e335e72fbff525b48538ba9052c3817cf633d6b2b495844d5906877a02c2ab1161b8e20e646f23bcbdc1b3576ccf384d9194f55141452fb00f", + "8df46648fd80adaa66537c42135098a217f8e2ebcba5c57ae1509ceecc761b452f65a2890866e18ca330e53aedbe20a5dd18acafeb7044cf8dcaaa62de31929ae879087068c608202b5ba0289e0a8f4e28eabfa4471cbe61e0982d5709ad71e40b4558ed4260ec5df590728c26d9aa6d7d8467070cd710113ba7936c47ea7e23f4e76dc043934f98b35778260870ccea43eef395aa15c200572c0180200398127b76fb6587ac450547ad86d84c8be09e5424d4f31b2d08888ecfc78c4a1618ae9af56e1ffcf8cc25b301d54040273f902a3f8a3ee66c64d894c7e8687c225a56babcfe41c09cfb1a75d3beb273833d421a283b9e1243fc2366a55f070fec1d63", + "a69d10c7797c1558e59dd50bb0f5fd37e458b19e32d7c3297c80a0e54f6435929629e08a0c2e580a0897fadff382f5fea2bd923f7202058f43011f14e6f0b971cecac65308e30c07c6024b7f60e58add69f2f42c7a0fff47ffc1fbea71467bc7b3d70c9e24acdff451f69de27e59e7342731a26595d75a37c4a15a03efbff15821d640e33f0d7ff867ad7dd505c9f3dcc7d53d98f4f2546d615f325d7b481742de258ef9419a4ebe58cfecb3b55d062058d7ec5e0a362535af74873d270422b844cc3ceb94103ed0d0ffb054e569c485632931c8f459296748973fa9eb5cbe27f21e4604f73c2aeef9c22140af4507afbe1ef51c8c9cc1ac0f3f54c7fd69030a", + "6226072c27111f4c523db1a2578b2d67c92cd26e7369b80752582a577d3e9eda9f98fe687b41e4ec9807c02406bdd9a7b936d95d6899794b65182a2f4690ed01bf04d4107e94551e1458221e8639bcf266685b30920dafaba84acf579f45fc6476cabbd7bfabe6b4df5cb96f9f369882f79016d84ac681f4d0ca292da650dc8932f2f4357c83321831e41bcacb5a33a471c01b4804fa914ca4582219d844690dbf3fe0978c257d78c3f9fcab218b2b560f24fefa313c7bc875fd3c9db8c5f60559970db31f23aa3ad1bc40a6c99b64b07719206b45aaf79957d11b90c3dacfe71a2e08fb1c09cace3b2204f627a722368b65fa61fda363f2e231e6990348da42", + "3b2e0b4477d53139f88f0e225a9372c8704db222cb8ccfb176cf776cde9f2e3f8d3646fd008fea007b42016fe1386a8321b7a9a96d5b6d24760f679376c70d9728c047192a64e94046bb8a17d9db38666eb3ab7f892c585cecc5d859be35cd0408a76bf6142f488792342aa947f06e9a6ec53939e0b6139040c07a8967945098e92cca1e76bd58095155e520d68187580b3f5a9db564e54cdda45b90d18a8afb9d0488c79d77b0103e7cd03f24e7d69c4c4c1bc91fce955dd9dc31a866fb6d9d77cd17dbd86fca8f35ee9b96438127479119da321f90a5ff483b061ec127aed91389bd44484ff836c413bf4262ca4f5819ee4c62d0072023d506b8f4b5a6867a", + "825d6abd0709f4e0281ac827ffbc01210a00b0ff556a0862fcc573c63bd9b25d5fadbf26f8da815cbebc4a26135d9d8c00e50f0c038c643fcdfbf921ba0ae7eff7332878ee3ed216a4b24324c0e1270d6d76d6fa7345c11d7fb3ceed0f4f33dcf388382f15079a02fff96d448e064f77d7f62662f46d61cd4ffa6ca753643a64d731bc429d5c03f041b3b0eddc8079c6e2373dd63f1d3836ea43bd632e834460c3e301486fe211fb0d78714dbf37d7b387737b8b248f2f38c86c71764482b042e428b0035a5a1c4a2ca1508479818f44fbcd0cc46835dbb675e7c6a2765e05b2e3742e4946053a855165ad4c4cbe4c94d16b217b37c81f4cf6287667abf4e477", + "41698ad13eddb22248ea847cd0d050edcf444336f0dd10798a12fea23233828d388642b9c005cfe373817c675fe2afe794707757cd33a5a26393032c2db568204a18d647c07a37444975c5e334bb07e5d098d0d278db275b979b871c4c5e322bb5234cec7ff2d8722106afec94ca6e2005390c283a01c572688698b14a04b1e993387b34ff03891b1211c65fcbf16e2afb57aeadf05cfdf51ef40d0a1ed5dcdc2a3702e7fa0e6afd2dc8d97d6c5c5e318ecee546a64690307e064a278c3ea2a506adb412c5ba1295f8238f92c9c6f3a4a7c30cb95f04a1706e57d40eae2da2181d605a13993a3a17c87b10652fd7023bcb4afc7a34de179e7e54755cc449dcd1", + "88f73842c116d787a25051f0bb2493de1ca0078d84a86f46e7cb9424b48d96029e2b650665ad0701893aef93de0a66959bfdd718b810374c785b0b8a0185833f6857290a27b6cd2997cf2582e8f0c9ae8038f6ad5d54077615be68b4df10f00e2ae99c6c5e506ab869c97fa7d74a62f00ffae3d5745784c5cfd20a3865f81d603a6e8880f939acc4e8b38ac39257911d4aff8ae77f544539ab2d8ba80b01d6cf8a14e0bb8368bcdd782b599a941183e9aec1fe80be75d4f7027a266c9edec9906a8d998f23d0100fcd3a0e288ca1c76da97670d1e597b16e7ae86cd663bde05faaf5ba8887def36c6aaf27411a35d2984e0beb8f968b09c97efb8110ce2c4b71", + "c6851caafeeb50d5d8f5c5ba6e1b3997ce191585c08cb0a0de581728cbfe0a46345886b716b978c2c533869b667605b967236bda055ddf9398088ed744e8afa4cbc1da3b48f4166b4dabc535a68f8761955dddf6e9ef1044d414bdf8d085bb918e800056c3f9040ceb0d15d7a4eb7209139bd6911256a221318cf6464da81a21b4a16d2adf84c732a4c8fbc27dc0a0c6130e7054367a0a40af8c98579e0621dc8bd2cb5f34d7292005ef804efd80995452520ee09a76cff3a9c4fcad9c451ae49606c429fbbf25604e9f71c7d6a9f02661311d6bf8c5cd6120144b16f128bb54299783c7b7345ba1f4e0d5e40f73fe3bc28b791e95965994c518f0bf65bd5abf", + "3551629b0324c7e6fc7c8fbea21a4aa86dab67cbbd35f2d9f7fd59d0906cce23c5176dbecf64d56cbadd61c17e232ca59d876f160db98a472e64fa093e57abde6aa55e6c8119031874e899c50edd350bf41be48e258825055869d52c3ed07bd0551afe7141442e7f60d802abe5f56747cf2dfc584af86bed9a7e38699521ce1b38f5984d7d16d1122228d6b67e493c452448c8bb72124e6c0aa977222242946c9f987e765347a8fbb325f88c7a8de5fa7d654420b29dde218a3da98a5396c62207d0c4d7657e0e3448aeb0c311129ee4b6158b670df2ba81466187bc764eab460091bbc9a099ffd7cf21c86e3826b8f0b000d8f303c6dad58ebac47c2c3521e1", + "1833e5254faca2fba6a8773a850575980ec4da250f5925faaf457b2b61652e94cee7b7faf022c73b2e699d9bbe69d2a65d7ac15b096f8c8285fce8d4247f363530524a947dccd7c84d0211c95dd69b9ab990e85b54dbb97478dba153a6a85d38b7c54035c9a38f529bab2b90dc01b83a39616d61998147902b989f97254453c88cb34c5d72f8d5df5907735af9e1ecf3fec631fd6347d82361e25c6c224b652d7270997ba3da50bfb512b9440cc81199a1af18b040ddd8e35399afe4ddbf100c758dafe6c8044c74bc34cc96d32bccb97d27dc0df66d0386b4a8be3d952d3d2abcac380913b716bf571e1c99d548965392ce4311ee8340ecb950a5e826133d91", + "24d00921f4bb0a684cd20a7d840639092a4f55867d407a87a901963b07f30d2404506ec14176cacb561b671e4cd6708c176cbf2968048c9bea9d0482fa937ca8bc019e461bd0d2d629d845ab14094fcdac2d7dcf9ace7bced4d4ab8f70edcf409ca103f5299cdf5e3cca91c639235f704a551a3f96b725938d1324ee15c1f263a66d47808049dd10c57dccd49e8061003561af34b4b854307d92adba038445b38c8cfbfe1a0b55e7eb6d4d1629f90c03062f13d272683d7208e08264c8bc7949ae46b407c57c4dff9153ccf14ec387b10211ff9fa7b94fc8b656c8c0d4a0b22fba410e67c433c9674433bbbdcf3872f7c16404f0c14f16bce6300d7044ad4883", + "c877c685add340b623f85a59daf248aef18294c60822f60eb6f20411ffad147fe7af3b1a1f00f9d72398dd9630dd7ca268f08bff00b409d7607eb3c49842fb68d8f8aa51fb9e8bed59eb9af5e54bdc5301375a70ceacca5e1ef1fb7f4f59151a42b5ed04ce6ec99446861530902db29c60ddc40d79fe02864e3b48df103825af15bc66cc9d48f5089fa3957450891ad0fc237bc9abca75f5f1a5f3a438c00d67af61253266a0cf754518e326144dade1d919b53294362cb1629c628f4645dd5bb3a0610fcaf596deec923675522d4df1ac27859b49f7d746bcf50b5631614b641561a9a77d9cb0a9766d269e114adeff709913f13eafbe3e1f7fd5652416c4cf", + "6fb8fa913024c776e0e4faf6fc81648ac3da534003f0eec0c5e83322657e240c082b2eae8b79c0d559d0cb1ca561bcb14d4e269a5c21d426a24e5902ab1551c2cd78c7ae58f91b1eadbef4a3438e4209476ab333c58b35487c032c66a7fc92a98a41b887d42b66e0a85c14512115491a40defb833c1d7203e92c7639ee0426cfd17f83ce423bd76e940df7dfb959ad61fea0bacd057ba0ff0a1f083bd7478ee5855edc2d3c730cefdca8a08a4ea171f0b5cca5e1a99f11cc351d19a5a22afd3a0aecc91ce5bae587a277031d3203f7490841fe59f74c0d84adc7b1620cd3f533620c094ec82e8350ba8cf246550f5c92de4df2e2babc9e3a815cc6db15e0c0cc", + "ce22a5611841e9f8be2dbbfdb8acb6e05de5a23993e36289801a3d147d4f067e123dc2fb7e4c06b90986f213b281fbc8369fa2ab458bb79bb35550d920573549986eb87424a168ff5617da8712751b18503334fe132d79c4c846019844d0108ed68feca079b5ecbc12813fc76d5323c531e9032b3a858ce0724295d3cc951d81539376c8e820118e510cd4477e98c88ff0732b20f7964bce0cd4e2e4a31a134c58b8044e4c8cf38cb1d72e311dad11100eeb5a0d779877700ddf9555a5ad78a992cd76682de88c8f561b0626b3b75aa0d9e14f356a3138a72ce57a5b4a26378008327a950262bc9741281f37bb7bc67cd3e0f0f62d1c8558ea1d8eedca0c1b1f", + "6791b2b2ace7ff7f37800f835f9428c6c61911b356b12b95171e81ecb22dd0b37c3e2df1f76c67bf79329a3b41153268fb22a8dcf3bea2ce5bc1d100a99314bf37f4dd82b9c24af9cbc93b7439f0b5796d7e79be610cb5e52b657c072c11cf5fedf176a3749552584cc6ea314919c384f9ac29807d52db1a1a443c5b881de2d531e1a6e7e941023d0a87ec776974f1b39e24bc3a1cac3910f1df1202ee96c6c3b9a092a186646196c96754e426f18bc8b23626f342fbc20c139b2bd8341796032a6f388a155e1452c9fa48b873f995c56cee80293fe5aca546a7ff35e9a0b31207915cfdb2f40752a8e225880bc39084a0828917302f1f507bcd31b2d7bc3868", + "cc2f7edfcb00487251a1796608bf984d9b3f18ff1b666636eca9a1f9f772e50236c6c36941aacd9449a984537572c01c54ba0e694140390c55c762fb7364b0ed5651232a0c6619e360a95503e48c340d4bee740c070c482ed34ec871229ef35cd410376e7a21ec660722c67fd526cb7f9c16038f66258f0936bcb27409895dcc9a8b8f6450bf230d40a722921263a26fb1187c56355b4cda2ad759ef0a1fd653a8d9180ac5d3ff7c384f5668093dc3213ae7a95b29fb6a3b5e7cf7085f839129c4bd12a27eaa734de4e4637c96fc74ca21d6138e2cf82f57f2b990bcebcf9a8381f04b17c3d53d72d9a9c9994975822f4a2290e408c0b7d7e4c4fb80e63e1015", + "912ed6a560c1b7cf6d986fa211d3444d9bfb1721887a2c817b9ea6eb3706bc7ae6563dfdbe7ac4c37fe8ad7aae48a5fc478c8f44d9a19962357144179c48249de8d3b136850663083678a280f3bca89855a3e15c99f615e9d1ef38bb16b7af2d6eb45590fe8fdd7a077a2295bec66d25a9a791f9af4eea851425b4da91c20a8f27bc60005a406a505e0bde36b1518491533b9b7322ba39ca34b2c7395630afbc78f8b5b4f0a9fd123983cc615f06385a36e6c3726a4c944370c33ce4d93aa3e6f6a5b0e238a6df2ad1f4470040dfb2c4eaa8db5ec12e8cafcadab79f092eb3aa49d511809ecd977a823a591f9590753c89851e0777d7f1885d43be481f231a84", + "4c2d9419a3ceb8602c38845b21501e0094148a9a13bfa6506fda486028fd255d0318d4fd72d5342324150c0c14c6df8593e022648e21db9797c9e1046d028b1bc09c65f2eeec5aa40c02b2473c78a644869ae781837ffef1a82e36c9fe824388c064137f52f1505af13a3ed2a3dad689f12949cf82ae115a7988035edf2599ab01f1449a453bf119404979965fda42457db8e055d18ae9e2541edf140e3023052fba88cae9365bee9760acdff87aba4a0b17864a21fc583553892b7e722a14844b2d264b430d5005380fcd00d21104e8b48d8872ce126c5de90ed1aa9d7ca67e6baef7b9d55b3c6cdc6ea0a08f89f4cd4de1cd5eaecff85f21854efc234b6e2e", + "2d0e1a5a943523287c5eb4f7476bcc2191fc648e4d08e67bbe6e7d93555c30a04abb8afac03042b230cd3eb529771bb170aac4975348da87c14612c2c120f721ba30405d81a5f06c40bc02d2b2de3f005ee2f609bdbe1dd55b6beb63eaade772848c1916dd29d7cce71b2653d7c4507d50b77aa748cd83295137873bbd739f8c099dca50aa65cd14e1bdf303302e4c5614ce07cf81d52c3113f866ef625e5753321f561196a8183cf7c0596e93fd75afec9480db0d18816ed8ac045fec49476fb699b97bc105291508012861f140b27e076893663477147632e177f5122cb6ab9d0019c20193e963cfcb37931f9f4f378dea06b543fc75c771c4dfcdae21ab18", + "2c070c898da6e05f4f9d4830ee6bed1ab153d0d17e69e4bb90c8f6b3b6706b1a471ac43d8961d93805d2f4d0356af554dd54cadf4920220b004da54ac5653300bb21d9ca24473acb022542a7d7746c6c4cf89df3e9caaa2da916be3a6b53d10198206477ecaef44c09eb9e85ee1e1b8dac46538039bd926c54a777bd5a77facfe7f2ca51d28357b4d9b5b347d3899215b5633795262ddee395fe9d838c92c73278de528bf2d3413d536bf3e4d23adcda3559c0fc89dafc2e443a2c6baf7e9d46e1d742f4a04e3415f170e7ae0107f7a455419d9a68df9e39ce8ea54888f975c848ef544abf98d4f368cd5273d6424985703225b70d018a060f3fc94b00247190", + "319ac4816abee8d0db7a06c74fcfaea3e4dc25f771eee40476d05460c951e4a702a86661d9bc9d633c1e0786bc69de173fb079c94059bc58ffc470e0b55a73a0435b8326a3f8de21c117e12d316169ce4249cf559a07e917c8b8cd636242119f09df6eeee8a2fdb0a8210a6767e6243a9a670337d0301d3b96a1fd82ac71cc304bf3ef79b34e54c0139dff0a246285999a1a529ac404694338c3cfe54cd26d2c9c6e2bb9d7025b887d2997aef99ccbf5d55cfe5e6b80fd24382c8aebfcf178b746501e6ec58eeda2e89c6d4211922daa4d62dc860d22e3d213fe1b5a745d1fb4e28fa34e21d7df492bfed5281403db7f9a1e5c161d60fd79cd71a703119d0393", + "5f83538f1a5f436357d98cad749cf0288c63fc6e280183a6e7484f1bc74720e68bcc298ca8fadc3d28540f867140549563e9989f27fb9087003ba238b842245c58a9dd18f5b61189837b43567415b86798709a1580952202a3b33c8d9314cd554bf5f30ff62d1a4efda2406f66445de846d4a6d2cbd43ee60f0b6d13dadea70827853fce770defd12246b43626802fc1f142dd2fc8fe97727594fe06aae090e27ddd044f707ba2e66eb7119e3a8f6f4cb4f6f9060b3293dcedb500813989f361d5f6af9cf9fc7e70e202ae9bac5f199428f1d11c71244e621556f1c74a92032226497bcebb503f28a81d1adc1cdfde00bc0c70be1f342c01c5e2e73f59c17fc5", + "c3ab79c3ca703155b13b5e5ecdf61763af58f21e14064f937d1c6d7b02c3786ba7a3e0f1cf5b06d2982885af03da90a2ff979e59d736949b4f51881e830034d7978fd0873711b90e1ccdf15b457e5a1d2d5ee335aa21755e5787d5e02626fcf99425c65ab69720f40d4308ec4a5171cadc9c5a61fcbdde1af1a88553f726a55d5969fa13a8f01230159c6869830a8174fee77a8c28e4d420190c6e64af7b0894ec5999149b9fb6af8b55536cf20e29310847796e125ae4b575f2a07416603b95cc86d603699b65123aa2ff75d2298776bd0f2b24ab37e6248db75a363d17d870b6114b0f955afcebe4d626e4d63f74426b266e37491d566e83075f3255669842", + "5bf82ba63bfc8d2fe2442b093ebadd822918f4a5b0af53a47b919b0834b7dd5b05d673b09bda165cff853d596aba7839503142b0afaad12d625334a20618837a54cbd8fdc7525948fbd34f8a3025de3a65b442c7f3dcfc074f103a71934c2a4169763225f3a99e79e0f1f3514a2a52cbb35166e8f8d4c42a0271ccc916bd2f65b7dcd7ae576bb41c2ee18d9da51cce397eb864e4f587b66ea2d265a14dd9e16ae0c092c194663ec58d14f254d660519bacf21f2a1a4844e53611d770261cf4e8fe7073419e762cd1ee701b2450485623a6c1b96606e011be73bcb54b293a5f700a19c218999a56bf9550b430d1ce211cc5c4768f1bc90802f8c95fc694b94af4", + "2e50044987c77e46fdd9a107182b0f09fdf44ec943fc15dc03fd981f306bdacaaab2c5f2f42e4b67863eb43fa6fa8ce2129d8ce4158885f34ee5564c7816ddfa109d375148f0043581793098d219950108d1b1756f30cd4d9c95d828e3992eab432e9303cd00c4512cb57a4224de8358e2ad1fc8a3631100df89fb87ea41f4fe9316bd63e601c3c16cf235fae286a9dc56ae2c437014ada0aaa2617b8aacdb79d058d532d99ad45c48d302d1a825dc45327fc0e6872fa0b77b804e3b110596fbbb9b3194cd8040bb88df42e03f0ab107370b53203de52097da162d56bad69900a784d37fad1d7431fb2f0f433854c833f1d6e61932d5c3a677611e6421427f17", + "c14381893b523b30949dd8e5d907c69003204b015673a49571efe1fa3609098ba34b94a2215f4719a4ea5d70ed581e4af26576b8db74ff9d0c9cb33c68d52541d71116c652a2826ae81a90868e96b88c6640b4bebb8251473b9e6fa423d028821ea2a0c573355fb7f5b4508b707bc22e412845811dd990bf98ff6ef2040873fd3c4272e5030620ce2c2312f9ee4bb5c0f81c6d15edd4d1e2ae5ae6c3d8be55aec04e7bcf0c8eca6a08389a11d93c203f44cfa8aa7da761d4aefa1ec1ebe3aff2725d9e650c03cf91abf7421f048129d0f405c55356e234400a9a10b2f3c994ec66593f7e60e6fcdb99ba6449cf60ffbedeacdff4abf4f9410cf707088d459aea", + "87bcab7f65fe1668f1c13654d6d33bc925c9609dcb508cfa165ce009b00774bafbd161ea880defda0e00c75e2466fcc0c8af5197e7d23ecc4bfa2d1dfe0ff1e81fcdeb7bfd6efbe2246a0d298b51c11b1b38d5fdfbc3a25c0bbcc4a3716a1dc012cbd316204606530d86f11e4b1b05c25e3a951223f1d7ab5c1378ed8c4eeef8f0654f3a87c34562cdcbe9dda5dce4d840752268a3aef429973053923f01639aee4bea5e246423551afc80f877dc5a4b380939e38ff066ee367d68c51ebab6ff90353e276e94e44d85663cb77a99f0644467018826906730e62a28e5246ba26b9d2905f78be9bd23df3d92f3ef56457735613232b6d99df32320d418b387f47d", + "460c3c4a276a0322038e77edf92c26eca574153668242e9ecec974dafd6d2522debda7e37a0dc9c77bbcd4344b13fd31a1b5c1739c5d9d3fbfa13d0a788582c9fd1620c79c77a230f99c77614db471901fe4a332bbb23d7d4cb250198e8f1a1cab8c24825ee8d37e2f54f03647507e3a6c9beab854362a9d155d97e27baa4c41de59949ddb88e9a754f93657dcb2ce8f679048c155633f110af930e85383606b37651a9ef218cfb3e1ae33addda53d074f2fe310a844029ad598d7b0a1b119099172e54ace1e451353826b6797b0ec5bdbb7c4653a2706ecc781dfb62e272d4c8db98afc5e850104c3c07f8f9fd472c756c8c011858ffafa5c204004c5c81e9b", + "d9aa20db877263f475f31ab7737a6218fa189adc722090cf07dde7c36632420e1080e03ee6b24f29b06df2f7dd13be75f8d50e7bc0b78e1be367b916eaa2651d7593bc6c64140b232ab2a413f7e5a4396fd680a125f58192000021f29352270bf608659a94b29d90ff19891d2d0c6c89ab5ac37350c7edf0e1782d8a1c6a2b7031094a9a7b2c1c9ca96d997cbe7d9dd97ff8f00914e7364ea08b6f93fab1576f4faf05218b714afd4b7e0f6c8ef154d73a7f825623f354a8e14292f548162512ffe9d7a56b41b06c56dcff36d4d620e8c3ab10957335a2b15781bf905bcf1faed6d77cf44456a476ab2f80149fb1e662dba904ff4911035f1734eea3b5a88878", + "668c117d43cd14cd904f8cd7d32d78ec0c60789763926efc1444ae2ffa2c982d4279df0fe682e67141da0371f70f12b0db2039ae1d22aefb94268884f244a723506ae5476b7897efabe119324b39d8c3a4ada86d8ab81a2b8bb8dbd43a4f86527a3e6f83f3ef7a0bc819a8620b3ebb869c3449c660c6014820c231a54fba91bc947e905c92b6257df2b943fe05b24a6873e46c19400f5062289ca66d17aadc7c1bd5d6cba9d1cb7d00c470d0b68cd50aab6d1f2cb7ce7806bbe5537c1695856b0d4879803ebeb6308bbc7e8d9e3f6f8a5598f558440381111e5cab2158d0de26113c6384411cb5ebd60e3a5735d21cce6f2c9ced6059c391060fca21b6f1534b", + "87c3faa72d625db1c8e0499c7034e3d93e22b273d8df0cfd56332b809d76a7d072bfeaef04aa8940a84630138a3567fccd1ba27086f96fd00114d6ebb9be519fe4abcd3d8c2238d44bd8d94f07c4ed417364397960f13956eb19d3080399191d4e4fc07a88e084c7ec04eff02b1a3a45327549feb31a059064967572caecbe2b64906bb17ac18cf28b5c31332df7270671f72719513e3be96cdc291d05ccdd5a07cdc0813fe502c45c60f38b8753d397cf64c6d2b29f8eadca7f7c11c119dd35e2d183b2ed741831f37c1b3640cc101eaf8a21b669e4cf577c8090c11eb8e425e4539e115149a6f6e839204943befd713ee768c4c0b3cac64b55658b9fd21ead", + "3f2626650d8a081f0c38309e9d4847294c9a49cd2d426fffd21285f656daace34e681c37a562cde8e54d23c6927e10318bb70fc6472047d1e85adc8d1176ef6cc5da2b8fafb5319da04da35e4b97317fb4b47aa8cf61d516225f9a441ae5a9bbc1ab41d2e1f036a64c8669d15555cab2ffa0a127165d4fe935774d2a4d30f64082740b4dbc160cf51e9e89ff560ec5c160d997b804ff192868446ab334176f705b031aa33cd17d1f7230814ecde8cfaa49a4552181d697d43d8920f2aab4b9e2ace5e3b6f5c02fb84d0cd1d5173845521d15bf9b7cf104f6feca33f011a553ee7443f782c1e6acb0367b89c4f9cb4b871bd28988813f4a7d66337ac0688bf260", + "422ba6990379c92eb09c3784339defffda0330495ad051eceeecd78ae7c4117959da140b4d37cded782861a6a7ee1a9ed90ece7ceba173d5cd40dfdb48853d4e9b20e52bb9464f84c1883a90ac8207f42d5906cb2f76fae48023d9588c9fed8573495a760cffa8d38e7044cdc36d3b703f43698ca11cd733b991dae8381134e031e9765729eb906fa077e4a4311feb93a2b11b83e63e67e6abc0d2b26b3b48d2c9698c60073f6a6d6848c1977cf44cc4efb989b10494ebf9c4c3762bd7e4d2099a8995300ad2eb25f304635b03c35839772403bff9f4b12f332ac1f87971614d41da0e14fb7a5b45847fbe1d35d2e09ddd7335dd50d0dc3adbcffb5b8e5520cb", + "4c0080cd9770b48d41a4f27842d09b64c76d59a872a30cf5ab267dd46caff02fa76e86ee60c8544898b5e88595de18b762b828c82e290b25ea4b33d08439f045949efaef7a02b57915c34c62b1f06f96401d4cb4b47ba03cfe73336dff5be91fd0a9f5a3499523520eec819ae9923b498d2f0eb0084ad43974eac1191468da8714e2625cd7a68220955abf017bd141b1e220d0097ee8a8e253b72e750165b97954b11f30c6d19f85933b8948ca184102711c92bbb48d11152b99278487be37b1d367a49376170c3a28501f0818e844dfee3be2cdc9f323b90e5e9922e9c65f64c34118358a6cc3df2cb445e2b2e01227d265b793ea017bb3188aba5b3fd7b449", + "5caddee890f6875f6eec4a2ffd6c1aa031425d4eeee68b6e23e0f04d3275912957b503a84ee1df49f9f0288325750789eb5c8c58828de844b4a3e7ced951e908dddb74cc737fa8037954aa4a9aba4f6538a535f489043ceff73344b7279b95cbc29ec571e5ef3fbc5e9c61e8b88a9548da5ea36cdc537c694a75a6c62da6ac965cbe4e10b54172c6bd46ca4b7d3d3dae046ded4cfd954f5e580bb07143455d5747d8558bd198552e8a593844a9b95058b90b2d28245485fac8b7886f148f80b75aaa999452b473fc2a360e1d1370ee7bc0cac38bc85db320f098323185a2bde85fc0fd2e50555b6b9988fad409f14f62797ea245b275476ef767a27f7a5a3caf", + "d77c274a57ecacb28fb91a4103f0680f382b3469b20aee09ddfc3c31fe74d3df7d1cc884bb1be8676cf854c0fef880074b3ff8e7bbbd03028d1009b4a5225c5f6663de8ecf06409a2626831cb9aab2a6fb22c605a9824af3c423c1995d5003d65d88f0cc4c8936618827598a726e1aa1ad5902ad9e43161e145dcd2e16bfd58a4562372156a11b5856dd443d888a87a123b81581bfefc3711cc10512d1cb3b523c547b12f333587d8caf59a49d4e30f3847e5b996cfb9fa338b5d640d504951b84ba34619c0117a0eed9992c26bc7a9f2dc680e46c1e97c9246a99b8e08c0111851aca0c0304cecdb447c3bba21a8aa037d7e19a092c120bc35a090a964723a4", + "20ad5c691a6852f98d4d2a8be6fb66673652301f5f9df070d6e1c3d54d0f36c975803ab52fcdf7557c9e405364d2347732bb7cf986710dc55a0a6c473e652add156e3d00fba3da9b62af2dcd4dffceffffb2b7af287d5acd0cee31291f6c8ffe2cf77eea6a3abb99f7f45992232eeb9ad9abb31b2bc1e6b6d7b75dd13934453051f3d7fd709ddffaf6d78c9a7e6166e630641b41225c5825deefeec13fb37a540afaf84454253bd36d287b1f40c6a84c7cecc4d71a0d799d68ee6949fbd04923713707d17ca3b155f687b19954b7624443d4e48f444d2609053acd5fe51ca6d33093b64dca201297e15f703baafb3a39371ef49cb9aa8954c3bd40996790a54", + "48456971f179a3b8914ef1fced8723283c90c21353bd6c642040ace34f32fe3900175cfcd735a15baf4d94b37b3cf978ec64db5801572221b56a2faa399d6a4c1f0d4636eb9e05c086795f8384f2385e1b5adb52dc63729cbc8fe3141cf736e7d974e3bf531d8242aabfc2f0a11b99a51df86962a52430a1a683ec65dd1dc990568da18491cb308006cface61224a242ea65bf84b4603626e9b988ea0badf56e21deff439074eddb156e8a564cc06edc81d3216deb7331237e4326aab8351495f6922757f57a04e21651d4a54717ba09a23cb2d2fa4a0565def1ce8ae8caae4ffa985461bf05f1e54e8ac6bc5c8ac81fc59350854b551168f1df0f51164a6648", + "a5e9b81c2041fb3a5b7e8030bf2e5af3fe4a7ef25773e34157d1d28cdfe55c34ebe8c70b05c86685d5beb3d134800ae6957c985f1d5fb52141c87f5965f020df5afc424421b70ee81673e76896994427973866825f542564133b4ee0b804020ec2159c70fda56d7b53557342ce8679740ecfad30cc2be96ba77144b799113021f42385b59aee61818b5d50dabefb01ead8fc236b510495bfa88c0c19b070a86f093e6575d5ea8ca035bd2fc0f694288ad875aa3bf48f276ef0564fdece604ff80c0d6e13842806bf3fc42f53dd5faeb4a02d4808c804f6e4a303c665993a8986c6083d8c17a4cee1479ccf26bb5f01e5f523ec82ba5947607102cad83b91508d", + "1e7ddac9b694220def2a4c44149aee02fbb5d86a461f022c352ef51195f40a1be3e1a711bc1e17bf6f52239e8a0d7e21f3eef28791f97db58672907b3305f75c51710689b058d0a43d0144829d4c361f5f0da4fc0f84914c7c6452b06cd23bb6b1591622f60b74dc3b33f7101d9bf3c749a63db8f19f3af4aac2ebfc01ebef1498bb66b778ea1c00c7afe5cfd31dce44e4f5ee6c7ed6019bc38bf99c00d66f33e25330c6e2aca362bb74e6dc25748e44c3b068d7fe4352df1f249b29181736ce5466d80c970bf8fbb7eab3f4eab59fddc164376dfdcb64f64103683869b20e50561187515cfca112e5bcc9d7e1e96200ce1605583947e8454f24397694297481", + "35731a254d9caaa734d96e4f854b341bcaa010e367c36b60503e9e0ccf41e6ea260fd668d948b9851d22d8c041f04a2d07fe3b10fdbad1395a6f38dd221b9a2b4ad5a188ef4894d565b22a338139ad61b77852a5ec87e959cf5cbbfae13dcd123360c9aa91ddf61d725439b3e3b5aa68376eb2e41870cad9c085dbcc6acc641d1b12c1a74b0dd84c1027a26e28c6d9b7c025a873efca08c7ed20bc6811213a1d99ea5ba2162150b200107f5397efc250d9131c056609c2d7cb5b6ca62cfbfaab2c0a271ec118c2019e78c0b5056a0c9f354082641d6cecbd4f7c828b6755643b1434bc247103059ffd2f315f937677c10d37628553b241bf7deedf9df11679ac", + "13163dd0981acf0a1a0c7c4facaae01d81d3e600091e1c35ec5821c083ebe1589f532191bc53531ccb8fa031b2f3a7a238dd7283903ff5b2870396430d6863280d011cf30ba68f5a08372d44d34cbe2a7b2b9985120ab92dfcb08e1eeed5ef8a2b41faa16d881f9ed7234333d17029f88630c8548738d3559a440544cb9009d93b7f1341a039b68c9fc6c391a0e49168e2733da1b5a53a99e3b3b5ef921b0b1d4998a6dff1e3055a4b94e4e9bbd563de26ec90110ac03707c6609287a1f830fe1c80a908d83ffb20b007105dd9a611ef9b5060873265d552908f64672f1ffc498f8e3ff089cce566efb4d3b7af0afe2fec29ae9ad4645dec0c5c8a9d3db4d1cc", + "d054a8f9d6356b32b8f6352a33fd07a827adcacc01536e43d4642775576a8211a263455d8de4c2027837d913ee4e67765dd4697eab28151164703e90cca341fa2ade3e688320c6ea3bc8f9da14e1d842c137b2ed19748f5afc4620282776f1d997ac12af88a9409942c5e93e8eba670559515be1a934ff2c300e1769f947936fb2336b1529cec82df1997e441787785e8792b2b1f7a6edebcbc9e08f73ce108a1c1a46c2fba82d43713d92208cc92bdd330a493bec9bafa98c66189656eaf7da5f5973ba57317b582ac35f0a228b347ce5a0f5a1f3bb07c8dbb7a6a04656c66a3bb156117826a9750c0a50e6b52cee0d2d8e737f0f3f57af9142fc2fafa7515d", + "d060913efdb40c1b809aad8812a78bb4769a77d370980df9f4c02d745b85cffd31f8607a398c355a1ebee13736205788a5edbc7f2adfa5a49977a62393765553a686d0744c54245708773515b2faee04537e262c2891f10e9cd8ee67b2fadb9f47fed7b4b69f31558b8d225f7c10ca8939a3c5970b8d8596d7c7157f83e582c7ba2e8cb7f23fd2f9255cbecb9b960f07ce4c1dd9f25ce3cddc741a0bf76883551663035b1b3f0f28c024ad56b592bead4964094775b9382c07363054a6386d0ecbcb0ac3983dbcd8bfe9675b748bab4b3006024bf422a3921c3bf75669f44b6726f60a6356330d7d882fd584dccf215040cc2c835113475e98f0c2a1aa9406d8", + "32c1955cae30abdbe0a1c497171b5322fd15e0ab49f08d3c8daa76ec99cc0b3a1cbf41c46be4f5a06dfefcbdd9e4c189f6dac31e6c35c13a105e10588563ede5fed600efab57449e1c705f2bbb95dea27059728f30b2ac28d09fde28fb225383b66124ddfa0a2f2769d84b35d8668b16c604385ac56ab7528e32c3bd62e4075a223a700e0013e98cdb96eef2922a9c35b1edfddf7908c24cc466a419ebccab85d4aa2260eee6b51de8a8a646b663da62d2063243da0d6d1ddd1be7c09a6cbc4f35939bd492067af9866b61aabbda7fbd1e3fc4e67ef16dd225debc75fe3fadebb19acf798dc2b6b82cb585e404feaf0efda88058eb00fd42e1355a1dc5e92244", + "6f8165f4ddfb13f055c6ea57e3c56d38a1c61c43d9e3c9a3abd46fc0e8d2b1bb426eb863e60fe2cebe6c5c0a361816dbdfaad2e03d70bb05825c41a6b43969b82989265980d6c7c7cfcb7ee8cde0755248f09176d3a4bdaf26b18ae2d8ba3ca4ae3be92ee943ec9d8a03394586553904d73938a174d537291c1c119f50e71699ffec05dd5b7d63a9b2cee3c3b58c2765395d703fab1e6ebfc757df70c55d44a7974da65dc181fc54efbb32b4fb3326653e18f18a49e9f8b4c6007455674877b9e4d28dfda4256d6b76fdac4ad9caaa9c2db509985cb3ba5b119625c2592fb260ad8ef60d918600735f99cacb1e2a6924d257c5c6430a1b4598608342a632effc", + "87d48449f459aaf321e618d721b5191e898ce618cc4d77e2498e5246766ad20029cbd1f4e5fa0475f8455c865b81b80db6588146688894ef78589fa6ed623c2abaf86f7a56cef0d04e4dc3c147537f05144b63fb4740a7d1b189e8926980c033dce093cf02ccaf5e84dff00df26f9629740780facadce00ae8223469254619e70d517ede26cc672022e99465e57958c2ee56d284eee853b15f82830415bc29942f702594f58a4842fdffdbfac2afb893193c3eba72f617ff309c8d83097814c6245099bedd45b97b9af152a96626ec821fa5109728a4ef11b92305c916c291941ef18d1a50edf2b962711d8541c5df9e7a8aedcb51375480359986802201567c", + "2add325088eb47fa28ea97c16d57f09e7ce8a72fe48169e0777a457fa68d44f20491a8b11a1c76f2bb06f3fb6081b58c7efb5765d41d04618a0fd7098aa189df863f97526443ffadd6fdb162ecae10515dfdc2a44ab2a5b68c4e3b6e5c6153b3eba950634aa5596ea57d146aeef6925bd3ca20f327588dcb7e4c4b7250f7114ce5869853282d0e4705f0ffa51f94811635dbe26e3c7d1618c875b4fecedf396d071c315384dc9cb139623056600a6d9923c317f3ccea83587fd75d911a22203426c7aec3b4f84c84a012050f83d9598d009bc33bbae62ebf880ba4e048d1e00866c2d17d17cc560e96d036ec13317e3cf7873360a168c4ab88709ac894eb90ab", + "4d6cd0b1bfbc4e96f7172d00e5c639b2d175c348115d2c522f04822024311b9ec892bbe3fc9f22d5f85e4cdbf46e0edf7412df742990e44b3db3d877b221b93ca638c88bdba8658a3f0cf5a3bac1ebe2f913dc6b98af414c05e927e29b341623b6da6318cb91dd4ecfdea17c2d2d170c6e55c202ccf4ae5c93af5959d66d6f3a7772772f4cd224a9146265f90ac6f4eaed354c10c8b825d29241fd1aca0c00055009a441a32fa73eaedf60ada0f0f0d08ced86710cec7c3d623c972336179dcd9854383072228f4d0fb8b827e5a3325bd2fcac64f68add2972588099e2128fb0865ae25df6685f45919a800be9b83c4090edf1f4c85ccbe52c815bcd14814b9a", + "d73f103211a120f7ffa4ea219beaded6f87ea91bea98c3ac871262ce0afddd75ebd57fb64f9d053a3959cbe83d6626f5f1cc740648c50e0bb11d2ffb66464e592afffe2f2134a7eae704c27aaad209a1be0d2998b9ea275063599eaaac69956e38850e4f4a5d4a3a5029e9888072f2261ba99f71eea1e51b7b74c01f6262db027de4085c875b8603444c120b4a5461b0da0ef4a531931257552cdcc61f381749b94b0871d3f3be5d927d3a2875188dfae4b10dcf5f1993470b868a1566a94e490e771035a64555d6cc526cf1cef7c872751f80d0e64905d6286bcfeb176c967df8546dcee261b51e8dddfd4760afb5e6b66157fc4f8c9ec12d18740ada32fdeb", + "a0e04d1b9578d92f0e2ee7754d5be05a2a5efadf6abaef8d32951152f8feae1d419fc36c70365c5c9b788b51d773262d9d0e61f13a67ab63eb5fe1492d113f0ff3ef23d1e61685a506021efcb139d3d80e737e0fabbefbf94e1193c6c0dc815ca54b2baca2f6a9789ba77031ab702e700471241ea33aec547c7853a3697cb1d849790e43e113b4b2bccecc9df3292f8ad8cffcd26907abce2b8ab4ff135ee7b650998c702d41934975adbc3805d330296b0783646aed26c54bff6469599cc624e619d477c49fc25d3cfaca7c313f21380c0066f6aabe449860496aa300ae9804fe013083e102604aaf79f49dc2220df5a9c5269a4227ba08dc1fff3f635d7449", + "350cb477f697f0aaf8ecf5b55eaf08b03115cf958ffef31a54f654ebad70356f1ce16d11e3ead26fcc6d611682a75a9c5871a23d19eb86c0bec0f5e7d26a25c1e4bf967e9333220c7e8bf97f868ee0293d00ffffecdf7b3c05ee2c5e89791ff3ab2d38c0d62bf0b869f805da4fa61cd51d7b5a1917d9a4fe9e6d77dd9bfff41b3efa6f84fdab7175ad406300970323978ba4bf6dc3294ebee34180d87c1db0d7386fdc5c465426b29e989583669b6bb3223f796d7813b54c9cc17c1b8dd19fd6dd0f859ddb392aa3ba13ead9e7f5eaa1cfb3734eecf22a4578abf48c980cb1988d826bd694b9a980b7d1788aa727430f517db996969fecc651cfee2ede4a5f26", + "cefe68e327ae9330f43e9a9e8c542553f9d9b7ed784419ae87b849747f3f610c673ee98ffece51110376e9a3fea923f73cb5800d99d6552475baa46e60f6905f2b4d01ade73db4003ad6bc3005c09fec0c47d9bee1142694ba29c610d744e0bd1fe3340315fab87ba7777d24db52e26483d0ec473917bc8b19c725a45a4f46848b60e071213ac9b46379164adf250f1e315910b8122bbf1a6578b420fd20d4b3312a0802121d683f8c27636a0060cce3a706fd022908cf95428f85918534975981a94a7d8538a6f2e40e96777656971fd7ec027a4b4109cfe25d22a14fb7e8554741027bf7ec36d919c330186bb00691964754b91631b9497d9a5fa98b21ea57", + "ab416157980a49ddb1c5a082c83995652e460910e7ae139e322a5a4c343859d2c5d071d31415357ef4ea4b1d4ae5976a5908a7ff415162d33d8b1a639b7f55394a5bb2ee97fd2f0669e3219bd8eb398b9a2e100aca9a25eb8bcd779d40e385f3dbb0c7bf6c4b4235c38dabb568c7f44da74612fd9d0d871ad24f4c99269ccab4cc5cc82630d7fb8117b18714957f6f65a0bc1cf31691ad553e255df12883e774c71509d16643cb88b3eddce57b59f8bd32125b0c7ed8388a429224b9dffc6917921c01651ef8c91cde956b4530a0e9f8086cff0d34a2d95d9823445099df7cab7816164fc766554d8c683d9a57a1d1b4588f2c6559a01b41f1a4590843d4fda1", + "1099018825498f385cb4cc7e9436be34e5a477ab7461bb32ff492bc580eb75c6bfb4530d01ad279a7995d02147b95009d8d996793a8b1a805c5c22c680117573919a0912c0dd4797c8baca8ce2bfd2718d56091a215bfb99159fd35b68bb85a439546e9f3adcbbfd962dc44cbfd792ebddc71185e879ba969c6c28182b49d1fe0318d35d0e77cfb417b55b122171839236c44e240ae6efefc078ef3d9caab329cd204e5c31f044d840d12e70447361e1dc0b48d6330d2b761d40d2312f0cdbbc39a2f2d6a8773ed26846f1e2c0f410f79f825433f5c9bce065bbc70982a7f3c4f71b99f0d89974b2901406c040ab3028cad4077b5b84d0348f8f7f329d2977e8", + "59ab489e75cccbb8cc00f1dfa118b367607a01f74167c8bbfe4ac08c1848460f3320e3c7e45fe91b6743e7281de5934bbd5eb0e981f683b13f0ea59a6e0e77156b6ecc2a9699d611921197344a20c6ab977abc433d90f5e6ad8ad00196b0c5c4630cecf94575480ec52cd691878aded7ed26ecaa1d5b60a061a246c5ab4daba4d94eb78cce6b48d2adab9f781cc7a0b8cd12b92921b968ce0d135382a45d0b40d73baf52f8e1c7f95de92bcc059cddf61cb517d70ae2eefd52043a1d20124240c303bf6f961c937f11aecd0748e869c1132469f89ada8d127fc56a93985e03047dedf3beca47d202424dbc2b2b2f59d52a5ca699dc0dc0872f0a350ae19dee35", + "566ab797a31c4570dff13fd4380072b723ddac88dbc3f2f3813a1f7edeb0ea1f43811c61c6c2f785669b5e6aae1dd9d74bc6e8d4589f1f657d18d6bb0ac9465fee36b4273c95f3e97ce9810a603c31ced94ba8d82e73f7aa90ba80d08a388bd82a274c0f3f13995730c0b1e4ed377682623c6b151fc6f39fa4481a091a5b728d0ee7ecbf33716939d368fb5347ad4ef7fbf963a7e62cde89f9ba607717e804a922180ae26190014622de41aca7897be656c8379f9fc65e0d5852a0b8394cce5b5f2f9228aafed8e20ea59a2694e0826b2be7f1a71abc9d7590fbe0cc6850f7fa99d7a565769c05afdd30683688536ab36f7d7fde9b461f6a0f8d5c837a50a442", + "8011df4eeca2cedef29fa1186cb7a2567834374c127ab12d7ee22368618c34d81730ee95fca903245e5071cdb621f1c9561f3d17fb0282b9fc74de0262a1263e28f816055f29b0d44f128fedb8984b037c8278a125cd610e0c234448b22c34d2ce509efb51b2b4de9ddc540db005617112a5028e7148ed49de1cb19390bac93b7e650734c4fd1c1b1873abf2c9bf8150e157820d9b1f5235b90427b566c7fe72bcd83bff623c08a850987bbdfc2546c202f643365df1d2ce2ce0109197b6e57e63518b9190ede5a24eda0fcfc1fc1ffd153551ee929e8ae5587260f7316a4b9919a1efdbf39a572b22ec9b4836ad3bc98e7c5ef1d4718a843d8b39d06af532c2", + "9f5780be38426404a633048e33f7177be73194aa75029ac658ac2db5f4f9c398d448f705a3ea4b353e124ed16711c61e12b1c70fcd075829a26b1ba0521d206e7161f48917fd5560f41afca60afe2071495eaf150f9d8ce00a60c1744c84b14c082c84d4ba1d2feccd8ee12c2dbb5dc944a9f2f25e62ba3c5652024ff969c4b480ed273dc17c68ede91c474312bbdf6b9792fc3108b3f53e7ad2693933cc337a19253b3e82837ae76e709ff3563fb7f1b4cc8445fe189e0ae18d4d810f422436546d16dbbb52d49d4b65df9fdc2f52c9f47a81f25dabfd2cee4df04609e6d55af0fe6160fcd9482b5d94743c50fda8fe5a3335ffd7827bb9cf845eacd0c7ab42", + "4a732dc26d02a05b1ef81ea2543795c42d201421ec881f9f7262da28f86da4fb3c9aa7b63879bd2b9927bef4753233e046af003f082578739841a7665a8794b8ea709eae548d7d30e98bbaae1ac03faec7d89de5b9dea04bc39cdb60d9fb741e032d166a342769adc3435bf01372294ece57970005372e8da1ec94bbb003826377add365f40609ba5d5559f6d79c6e8610796b4a5f9293b0f91fd9501a3badd6c5adbed0a710488ce0ba74e8dda7e2b585420d950020a83b3573e7a8fe88b45b0cc39b01977a444a543ad5c0f24e8c02431f607bf19ee12c86a2cc9db73a482c0052d426b83098b9074fd94ee98150ea1e4d6478ab79f72e5a3617106dba2d62", + "68fd088af439ce22cb40d2203ae38c37f0532eb9eac6f9e0ac057f389c16901869235721744c22517ec6c1e087ae9bd78604d10076669d36c36438a8f5086fc1d89b94d05636c3991de040da30f8798c4ea8cb8c2a944ca23e729a3c445f4d55807c6bd186a6a4580061919b2c096f18bd65c32c0f5c9c2cd1d2db5ed69f272213a502e982ca4fd1e83e1632b71926a58727e4e1470eec729b9705bf04380d4dfecd6821a5e1afaa88d27332e8be9012113d7b37cab521199eb2128548374c73a853975a92e039e45e2a107c15acff5340a2b2af8e4c0d96ae797626b28f85d2b1961b34e3c6149c834d30025f8c388cc85c1be90b4f25411bbf34a9e37716bb", + "3dd68589b51823fd9dee731482ee3776af424b5d92eee8e2d7f413ff7c3a05e8e153be9e6b12905597073de0f02d49ca22a15a65863690ced853c20a91ff4f28a705811eb2820e9069f0069d3048fe75060096df81cd2f8b25c4d54d4268b760cd4728e0a69b75c511e56d1ad838e306d4333cf03cc66c17e2d282e4de2e32795d93c840e774cf5452a4549dffa8403db9e66c178ce4820822af2e1004a74ad56209272aef02fdbb283af574dc7f164ebe7fb632a17bdec421e6e84f60a70c6b12c675a65a83cc0c0d2147f66071cb44d86e5540725365ffb0e2d00acc1272031983652d219f373fb90c81b7e54a2f1ab3cc7b80ab9c69a055b58fd27059a2d9", + "8615f7053a1a2cf537c1c723775ebb975f8e2aea1d40759db5e45da2f8778326011274ca13c700bf90ca6cda0aae875fd1f5b49d4ded8a7a6b379262b11cc767ab4a35828cd336a6b3dc0a26e8b7d80f0dab1a2d648a8f54258070e0fd3247cef6309b5f81f6218c4f295918e3afa9c548f315345d6934916dadcbac81b5c63d1285b94c7bc5d4c0e27aed663cf2bd5455bf1998fb7c1c1025ff5f2ad687bf433f85857beb4b27d796c9be99a187576f2273dde61448de930641c1042c1a667f589b280ca9833371df89af4dfe90c8245cf5f16a0f3c7788ee19cd21ddc1ae4530c8625854cfc79ed6657775d3402d677dff14b0061ecc828477641304868620", + "18dd832087f244269452b9dc17709cf3176d46828b65ad696b5d313c6d9bc0e6a6d61f637ae35cf1f706b2d2226a23b50f275ec4e5f06798f99a72804747d58de5839814df3423cde21115ed5ddf271b3ea784fe2d7fea0a4d1509174ae3972f84da8168e33edbc482a857ddc6e91113b3e32ca7a3baf61c12f5710d9c750b85ceeaca5f17e49a008d12def118627ab01935dc34b707459093e85c35d1cfec6e9d347f79d955503d461fc3bbc6886ea84f1866783e836fa8e8c799eeffb2fc3b1b726396ca5b81f849f3e2177e6cad6cbbbc5a3525da7c9ad26a45ca27ed31df4a1f518076d4bd516b28c9bd3e9d11e907a1b0f199cc9af38e16002ad0f265d2", + "559882326786667d3d48b6397ccb36dfb31fbdcfff273811c533f1ef5134efd2c971cfc1854cf26abd1c81f4c8edc03e01b10ff6fc4d7dd72653c4b32d2863cc7c7cf8fd11db91ffcb95be795497cf585cbdeff94344ea6264b2cbdaf532d065db432f97c113d04c08397bc13ae39f65b40db90c8de1617087b4a56f8ce91b5097b82f356b26193f1341cc9d37d43c6a5c72bdf19e7016dfab1379fab7ed6d588084732496b3f37e3b97a8804ecc934ec5346f4a1a0dbc22f5c6a37edf818209695f441c251c2cdd5423355c51562fbb11d1eb4c437e885ab46b44a58e5a04c208a89901c08dc828bd430c07813a8f03d6f2bfa2c976d1ee575061d6338084ad" + ], + "carrier_wire_sha256": "b14b6b08d96aa6d15159ecf8d4c8fba8a55dceb2847610ce62796f48ce93e35f", + "challenge": "fcd6d96035b6c6631d198334baf5d52cebf3f285f131d7f04af19e0adec4c61", + "inputs": { + "h1": "4638a1fd72f205b157b62fdc8b60136acae6043570a6ed432179754caa7f3381b66f6d73d1ec88b8fad20902734b2af62c8ab781e4a892aa834d57533e442a6701cf8806da1d1c258c26184968ef58df1cac895afafa5763701165d6aa04cc38033ae37260fff0fc46b97168cdde2d87f2a08e727210cfa6c7100780dcee6ec0be29feeea8d52050191535578ac8ea6af24cc559bd8f8172a6423240be0e4575d69b1b45d52cd33dab22d737740e94c1967f60f7013b9ad2a2fc0b24398b0687e0bca15d176a940e15945657acf745bc48ca1e033b2d6238f0f8abbb897e73927778eceeed7e53e9761e49b2653aec0ed4487f2f8a6e3a691529492d33bbce91", + "h2": "4d91da2d11aa6874b7419abc7d4572806ac7fdaf6908646953cd164bf2cec233a8d4f8ed0c93db44993b15e2cdc8af28dca2d0d416a7fdb07ea63d0bb3d5f8edd2bb4898d2f14738b231b8c1d8dcb052e8fce682f0fd4713adc78cc1d30edad355c6509ff6ccd62de6fb6507467c0a692b45f6e26ea8bcf506a38c4620d7a196398fe8c64e82bb964fa3535945cb7b1c0fbd46c82829913364cc6aa4c4d848a9797f8dcefe32c60f478587577bd50d7d1349499c44a6ae68589030173fa120703f3ef58186341b394ab1e42191734f46e678558323e2b870a815bafe6776dbe97cf29ea0fd3581ce6220093f84e5390ede274e67b1ed92eb2687a1e4bb4efefc", + "n": "da48ea954fa9a510bd74dd7273e047a5a1fca96906190d9641f5a2653a17163d7b888d1c524e82c51a3523b4c7cda45b4789134c3d716ce4e194cbc50a6edf761da800c5331c4d957b00b84ca8e54e3fdb481788239dc5a9d6af31b1a5f9c6087ee10286bf730ff2b9e9cf294088815ffe11faa980b5a735717c16e1cea0835115287528b61902a9320d5445b81ea6ca2b67eec3a9224af2bceb7993ccd2f637ffc64969e26e98b7eaffc317f8c75f001f0e828428b631feb6e4b6b00f385dbc0355d025f56f48818b40bc1a4a20a61df2294c438566ccaaf1718da504b67361dfdb034da9cb9add2d3997e39283df736bb7fe80804f1cfb4ddc7074fdd4b959", + "p": "79659361127f482628ce93d9f934757a464ec2c8eefff3c6af1622afcb081db84ccdd3e3fa5b53e3b0740b456fc9a1aebdd3985d397e6ef75ce74388fb830425e6958d4a0c1027a467029334ce62e30777f6540b062e7c014459abd8bdffbbe0dc9ac96f3afe6175fd99f1e7ca92f98a1273817438c78a200d96c3217620991d", + "q": "73143e381ba52cac992f5608c56b67593e0d8c33948c13614b07c6eb1080c5c4d49c6c747639d3c9383d008651d857f4ffa8686f818e949f8f074db92e2dfbc5db353212d6b14045bcafebfbd0b235a71ec134d23dd3ec15a50c5f9377ea9f0fc03c461e04a1aad74f8153798fc31784447cc2d88fd9001590cd498a1e9e2abd", + "x": "235239a581447a6d9c9877145e8225e3dcebd47d9d7298a7e2ab80301e877a7f367de179e32ee6f221f026f1e85021a04d550cd4fc4145f07006d82a8763e267ca900f972f4a6307e8c2a6c3ca7477bec2e2b2c7c3e6494d7a11b62dafe376102960350219d21cea602cd5fc6b57a0233d8eddb7a91925d24c759d3b0c19223d7716a06a1ee39d1149477cfe39e80f715fe9e189d46b517fea7be35767d8ef3f7ec03f6bdfd964a52174ee36efcc0c5e88d4c7067a6294093d29abdad1810fd8071dc0a17efb3168c3ba76712d313f43013b7aa0b2e444eb18b7390ff89fc8bb70c44929e3747d534345e94172997b433a1abf26fd983c8378f8d33c2a2df782" + }, + "t": [ + "14e69648e7b9958049afd2cdfa4645e8a0083ec11325e32373c7e05bdd84c6b2afc79f64e31ddbe0b1730cddf0f88306726cfe85adc51ba166f06833d8124f1a9254f42c89c16f7f4fb5d04b35f6dc8b33d7c6a8fc535fc10f3b82804d193708307ae624bc9886afbb315f87c269cd9b0fb4ca77f53b89477ad5f00d6fdb60f40eb087f58c206ed28a3f8b1ac5283a36e9d3cb37d05fdbcd2ac2c2e0e9b0bfeb8eab033d61377a80248223288049156c75508c4cc8666086923250cc8cf47a4f69b4eea460fda9854c1141e8fec8a6ce7a4d2836217cd8f3ae446c967617ae04da924e039ea047b1d48675b81f8ec4e13c5bfe936413f816e10bbcf14120e5b0", + "6c4d98751f6058db4d3d7bab121c3ee2a3bce44d832926c1dfedc79f52cddad942514c78f2320034cfcd376a7018c1acdc3ff85be56322d743f9daa9999d4c7c2ec4129768d063b894608c34d236671b6d660dc99072830fda97b09afbe4d8b05a8f6182e1efe08adfe80372919df3fb4ec389c17c70f921e461b9b21cda8c292ac5ef1fdfbbc6e56da3da0664ad1311fb807936f0569e6d667cfcd98b4aba01306967f2e876fef45d368e04b57437a25b69c13f1abe041fd93bb3f4c7f20d736504808bbd30be7435221b232eea955c93009ecf8d226ea1b255ea3e216f253ba309f83b20fd898f9c3c3df63600ac00eacf31fab2d701b7fdfdb71dedf3c04", + "1396d5b3364acbb3bb6280abcad8a07ad6174d78503c591d77f619d52113bbfe0222a08d05d77a4823a3f913158adaf27a0f1d328529ac5794590afd80f07258b2cc5873f0fc16aa87544a311d37338478aeb405fbe34af948f5aa2f65881948b8ef15b667e65188a26f91c8ae00c6de140998927fd303302fdf97dcfaaa2ab86501fbce5deb6701ca1689895148ee863d62e288fa214108e520aeaaaf402a72a5bbfc1aad65e8682c69259917d68cf082d608ff8446aa37d2aa90f1abb47fc71470c7528e40e20ca327ee885f72d002a1c93513a0f727591df2c55d1ec234feb8b96ff39b121d6b63f78cc57b8eed9fc3fb047695f53b7b551c119c1dccff57", + "6e30f0f5112060a1cafbd6b15032d5a21c78335f235d000c04904a9fa29a58ad960f7e17a49f6ad4bd4408b14cacea65bc581a91dbe3709442ce047a260e2dbedf8526737a2f88ae8904dc085e727d83679661821e347d5d063382bbb5a87baa7d8f5cc358f94b2ecb3d828ea4c01ffd52e9fe115f25a06d9c4a06608650a80022f347f23c0c290dcee8f16b4488a4cb787c5793e747d466916d953952a68e7cd6236666a8a08ec5c392108fbdf569d3c635d28bad578be7efbcb029b68bfc3055a581e4324752f813400d387036779e34efa1575cbb27df352e3c14b75332a45d75cb24424c9aa94acd52482fc4fac30c3c5bcf6db6c324df35a196aa77125", + "8becf54cf60f08efade3f58f2d57d5a256aecbef76dda36a6c981ff0876f7fa419782325e47ab07d8eef8f00e1bb6ca2bac36e4675b5f3246e7653a11869b87275659889570534c0e78d1b3516b3277a0c85657b6b77c36f7822b35a12fe14dfc3c092c633475859c3f016e96e2b77661c4e9889d7e7c2db93c4132e3a12c7e78c017b4a4a011b3ffd194365b7a1099bc35c0cc7aa20c7e6314eb467eca47110409e665e509e9c7d10748efc61c3e2acce72105d32713703df76861d7b2960eff68cb524dfd8c376af913887a7d941145626ab3f1572ff5a0534e0c630a505ffcd763721799b48eff487b378ec8617a49df712a8b01c9148209fe61d6441efc", + "2eb4ff17dac4dbe1e6159f20656145a2cc785b72a0329789da596011c76a2f1ff033071aa94c89eb8f74b7e2c76d5795cce2bc8d57f89f5443be5091b0e9cf70b24737d29b5e2b4c27e2e417cda1b167897a0237582bb72852256f6ff5e6c6a2ba1841cc6ce3994f8a48f1a5ab72a4f9af0aa1b8a764e4dc3b3c562bf421aa43d7bf00f820c02dab60cc3c62bdaf2a9b53f83d376781271197e104730c15e71add688851230c74f0cc29aba2b78f22e624914105b6b0ee4c9f4fa0d8b6e37f5b332a45741f4797b698e99eb192d1b35b4136535eff3b724be5ce0d2d67b73089b7e8902cdb8676aecc1fffa5360681286925fd51e96c0bc3e539276bf469d1d7", + "24365eec6ea34401350a21150b000d163415e4c06be945eb6d634641cc66b09e766374c1844364d3a338f6580283df7d318c22d95da7a9444d34a59ff7d0357f89a97639b1d22946fd9318d4c9b98f702a22a4b5a74a49c902debf8dc12e9ec3731ea893003b2c7faca47d63df6b14ebdbd052e9fbbc0224df14fa00bd643e1a3a23b2860e102bb74a683da4804b30b17825d1f94972ce84b634f34d5d8aa3d2718e783835acac741c40687c132ea3868bb2fb33291f90ac185579d4a12d4e7c4f9f3baecf2875a338ec5c152923a0bc5b3128949891d7a46743031f124c00774afb3e6ae0c0b11c237be2996bef066f9d71e3335af99de4b286fc07e86216a2", + "4583a8cba02665c7c78516466e3068c0e1df89de4301cba4bd4fc16d948274540c8dd8b90509121d89e1206c529ed5fc7c262fcdc11ad834235548e9d9cf4494c0e6cec1f1614423d5a165edbf2fc64f892905ee3a6c1c1c61e764a4f62d3af13f2d422602eef597679f5d9f707fec3cd6258fed04c9e50b68be585329b65227acd3bed9c9f473265917fcd65ab43667a818fa8b4c8bd1555b31638720d10782057da48793d0fa657ba771c4601c6c9a5109135aa345b65a69fa7b79d78a91476c500f221f76e4b1ddf418e0a0f5faa431f39bfce6b9b331cd26e5d3b09dfe4337241680d9bf90aecd725055c66bf29c580adad19fd1a2fd4e2ea69a1e653c8", + "efc5a9780de5202e93ce3928d0e2192484a272a606b12cf6be5c6e35aa4593d06da09e591933f8832900e59f2af866ecad4cb2b4a0957eefa0444bc0975200012859c3755c091da8a578438768d12be06ec6ed60b9c4c57f6e313615bb016dea90584dba56e86aae453090030940a7a81386167c0822276cd4d751c6d8777c94a28d1a720ec6a3ed5e45c0ece76dd8dcb52e36cdd4777d17a279831d0267fd259fb7ea30644430ab8b03c4c110119acdc154f9a83db54242e6d2d526a17b6e84c1ba7932a8757c8adec04ee93b685621c75b30b11dfd9bbff0561a19ab1ec48d627558c38e9761542749c1f25ea8643ca88242685e6152adcb0fb93f0c7342d", + "21406f0531d3ffece586bd53019e459f8bea062c5d391e8563b17f7f36871659468eecdce6e87338a7ad7b2dfa5bf14f8816186e55c8dc614bb0a8f3d43593a27f75e7e9287e0670f9a3cbc3e5be708b01ba9da00424445916f35200c3c7df1a3c87c4964949ba2bf953470f135f42c20b8a06290ef8b30348721741ffd2eeef11ef429f81123eee63a78df9238e81f91bb8db743b581d302e2957bacc5710b9d5914cce64b874f1754aec57ba402312b3546326cfc4f768eb0c664d556c8aa130c33323a0039881e4df53e044ba21b3e2173d15c8546897393b4e1aa71aca3048a1824369a91d855fb0fd9c3c3e81d502cb50bbcc57e4ec66846c314a3770ee", + "4046c8720bd884dc257bc324f83dbd71c97f452bd425cf4092faf70f0961e6a25399065f005abb2d951fa8d65478003a19376bb5d51d23d8f009fd41058cf3eca904ffea487ffd39e6304343bda05590861131e5b0d7c485df415a000b2eb8cb3797b6d4b0d6932cfc68447e2ac3f3a5e8d2c84c2cfdbbb723c801d9c7df628f880d745029fe80bd6913282005a865072ab79f48ef436e13273c4afdd605f0500249936669712476dfdb5e089b9d9ac32dea2280cc3949b2e9b79d5b9cff2ece676876957574aadf795e424173bed448f89aeaf2205fd2d7a4cd0a8ddbb71602152758348956f6b90dccd6aff55d8cf422584e7bca13afceade01e600cc8eaf", + "13675687edb938f239a651fb55550a8edb307f6ce2f2986c132c9fc650ba97edc5102b1feefaf4f3691dcbd3c1b58bacfffb12b8f0e8a471db9e3fc0a71763c169de5c7504e544e163bd3b60b51270998ca5f8a34594f3d998ab98e486ae9f42eb59e9a731a70ed3813da54c68939261c84fa0761d2a951cf7f06dd063135db29cecd988f9dbd8e7a3e02ed8f6f83b3580d51ae3c3b76d102155ca5285c18444d9ac20b33f4cbaa25526d8b1c664b7394215da7a5b0717d6d46af01d7e1d93e1266a16574550f431d7f2a7e130506faebf8763137bbc7f4ef5922f383edec1d4b6b2c2582f974010e8e9601af28dc70c62807a17b8ec001b7821d58a2ab871e7", + "f94e78c240f90ab82c22f98781f9ee37ec1980b8408c82386a0612206285fa3273d277dbb966d348274e06d90ca75f746f13d750271467ffef8c236e5d295f3604ae6f2b4452c750f3c57c6b04213c534464fd059a68be54b6dcb68a8f5ed35b40450a401a05e4b16ea381ce2cf3e58aeb4ad0782acb72777913149c3fe8d02dcc2702c17791c457a553baae986b820ec82994c8eb658ce0a05094adad8f24bc568775386cbb180ae4463ecc92846f74c48aa3b940633b8e36684b85502158e4d42350aeaad4d9156020d5484bf00f187c717da19211c3f4e9e5109295d96090ddd8a71d87ccde2115c874c9f77102380eeca7857a76176fd06f8e731815711", + "23495242415f3587937efe5f397f9f482f77a1f107f1291947edbad775662afda4ef85c95f9dfc4d1a98e8b34dfbcd5702895f6d85c58a7b3337387320a73877203bc9b5cbd61cab8a797703b24a07d7b558f7d44678578738c5595ddfaede5166ef8f4ee7e6b447c1a3390cba3be39433d00b82a09a4321e2d7bff66be461616bcf4ce2b89c3501246eedb00ed6a26edf99d4d12acf00a08011804354f03b68648b82b412b4cfe0896ed96997215c6b40f1502242928ade2265afa353d70ba3e076e5e87709a68da549b87cf35371f1187e253385de88ef9180b6bde94a70eebf6291b9b63b7546a5737c7c48ff93c33fdce05e119544e77bcfe5a2bed94388", + "f202b7edf12065ebefccd7d27e7d33d6c2eeb664d7a80cd74ea56ddead38cf963148a7c106c93e3472f7b362c0b47d2671f710cead34d4b0b670c593c7323c0776f0c591e996396f8b74a73ae8b8b6d30ddcee1c7d4ec4222549ce3472461877091a544e9253f8ec3e210a187100eb2ff08e86634364e79f64ef39e3da3597aef5d224401102643188c945b9cb3cf5468be41e91fc2e8099903e65b7065534d9d2d28f304be022c1554ed5c37ca9407c9ec2216e316b74775459ed1b5a1d7f67d6a823f06f9b4b305e827e8df95c271f71cb1320cc08864081543b7322140eca6c0c274dcc8f7d9874b7f7d67148d65747cb1bfe5fddc34616ed063ce8c41c6", + "2a65593062b37ec2ba60c4a266633b20b499a70ed4b95da44714ba8d3e20d4527ab04b78d6aa2f9bddab587bfb22645352995bdb804db2cd3ded4b1e93064cda4cbf9fd7eaaba8ca766b5486f52be26a1a79abf7863faf25ee27fdc3a357300d0daa68f0fb05458860688f6c53438c84c53497cc5161748f9e6d7f4da971852fba002bce0b76a11357fb4b4a67be7ac32a85b08043d05901e6e0938f12ad06eb155cf47308195620bf1adb5d535144d9e84101ccde93065a93cf518d36813a088833efd1a37def5ec292aa650fd3d1b143a2baf1c2c58f5f6b3c70170ec0904d2e2137d402b9892645147275d6126cf41b1434db45fc49f501ce18833a78b2cd", + "331536a64151f16c89d62b01387c31623175660d1d731f24d201f8454a1c28f45af0a8e14fc7591d637eeedae7e4921f2ffabb22127426ac8c36847f7960fa35f1cc29f7fe1db6134227d24a773e68739cf4b71798832d2f52f51979d668e53a417157968f8bc89f90278dd21bde90cd7dc5f4e179e62e67c3c52eceedb3607a64fa33430221b978cc38dc6d12d721a2b22c191b0889fbd12dcd4fe4b960473c3bfe3fc5bc424b1282501ebe407472c76cc3e2880b4af25bf27f2c286953f1e4b7c4060b53ae1ce794c7fc46f948d3774a68a97b1bb14e8566f6fc5d572b793eb623ff9b725898b1783e71ce3425736646654ddced67d796635c6cd606c1a8f5", + "27e3866f8e8e6d235bb498e69476f2c3ffb4a70419f180f48d9fec4f6c4d5f5a0e2090890372f9af15fa1891efe9dd4bc42341dd71207486c5c66849a2e18160be0ac2da883434104717ca83003e629d76d42142cfa395d065caf600a9f76fa4fda319c5212e7ec3be87170368c04a00f696cb0eeaec9fdf5bc9e5a47ee01a6b688ace31335938d5701d030faf4d870e4f5cd2fcd19949842a2e1073158e87251b7d9e8308ec3072cbf14d2be323e589bedebe388b11d769cc279dc2e8c36120cb45ce00da412557df3dd81a52fe9c03c1ad7a2313d178bfc1343f4025396898a2759e031c206f01ddb16735db11946e7614a3681b4eb62ee000eb2cd9946ac8", + "1bedf92c8a97c73c4214b5aa4030d204d493687dae0a92633b5accdcb1e930558e333cb083a821f78fb863fbc4fb089afaab9c0204a7fef6866d8f352d22bc522e88bb9cfaec71c1a9242d45bbe5b6f94a51e30a729397b6088a4b448d1ea9d3e2a35d9df27943d143b7ff95268e1a95634418e196c5c229b16ea697f7b062a8858a13728e14a522c3284328bab6d301e50ef7e68864762c2e19b45410efcd4fd9d763b9e4029124b7de2d2fd344d5d717092d1c0d1aa811b3d325f9e84787046fb25cdf697d62b4264f43ee78552545e82ee21f24642b8b15289c69dd37e7b2d230cf2264d47898da54ad8bc5934bbbb9d72e8d56ab5ebec6c1154af96e3069", + "2253cd8c74fc85c35ce1d957a9fbf2b1b814a961a0aab482d73965947266c6a1c8fd450be2c25877999a00f5d86d71b95d6a3f32cc1adddf58893fccff12898c66631f5a9b685a91f1970846f0066196cf45dfa32004c03f2d2a9a479f1d6445183489ac14c9328fb5520ca3db9125bbe1da51761d7456c58b88249b44ae99c3e09aca504c987d941e7960f04f36291bcdf2aae0072fe376424b66ceacba3cb8005572333826eb9481240fa71e35555704e042d11c82537ccc8ef3f2aca78d308b7ac22152acb671727b526cd3c6ac8d4019c0f003d21833629d065441c790c10cf8d77bb07c7942b73f833612a6197a3d11e7ac39c3fc98e7466a6b3b482878", + "18507ae76404b415bd9682859650f5f23efb4a2f17155811b05dae96a174058b6af46dc7c42798ec2d668a35b2721fab1ca85ef89886932f5d6e11c5674c31348fa0aca586fd54061f60ad9e5f90dbfc3585082ec5d56ae7c335074a4634caa14cb0c675b567e57d9e048ba8a3f6f559da677bef99bd9bd397ad64ef59cea4b6999080776202faa9a4785eb83e7745c32d8ff895d42a1131ecdebc166c398aa3efe946737df56f43339ebafb0d85cbf413d042c7db4b70aa4a0c050bbbe624a2be4ab8142225786adf3426bd1a5cf276d67725288e7f2016e32ef8ad741ff314e89529d66a2dce200babea801d9e30af743c264c8209ddd47d4f5454a0388aa5", + "84149727b4a3e9c43073847d02d711eb4ac2bda2f1d5b062a62cdcd814fab6cda49a4ee816297c8f18e4eff52533c5ececad5bf6c49250e240d2806b3d91f9fa01cf92aa3b5c1d2e275aeab4a48a348a900d30d553cde046cec16610fe754690cb6a15a20233b8f81d4515aacdb9b1f6e7a2d6ca9cf7d427febe2ebae7c5b9be3abf8215dee45b88c9c74ec354a80a39e35e914ee686ddccf3265bff71f1bc10b46e659b2d604dd1849a7dd832d01b66be4e5378027b30939d8e143728a6a9aef98c19908a4db2c6284889516130d7e36198c7d40ea618767fb3c90bd5586801f032906402dd2db28272aa8aee600def166aecb33f21c077d6c2087617c5d88", + "3145e469053f3c38f4cf5a07d577dd66b6bb344e0f33d3711598c5551a6e345db11b7a144c9e60ac37357019cd81f7deddeb3bef519fdbcc6538b61611d8d8a479997418e9d03ebbfe9f5a8338631adfead0c1629d7d747ac4addaaa527708e739f71cabb64b40bc6911f25dff87685c48d3a4f779e3f7ccf1e18ff15d222ab381ad96bc25feb414d5eb862ce7d1cb60cafb7135bf57df0dc25df8600e1943f2fe1c209d41d5c4b9072724ed154656884ddb589fb240e880b3749616c8ce10c1fdba4bdc403dd865736e4ec17eec19d56e085e1ad8c9262b802feb7a679e6c1ae5da6654c69c70a063dcf241297123227c0b3e78585f433c0d316aedd4f75e94", + "25b5421af5efc1851bc9b5a1e6f46cebd36d9ff1657f13a82a458580ba3523f42bfa299a2205b2109a8d2998a8dd8111a27314683b715261287a4a00c1397bba3c4d79aa3252fc5cffd6e26bc90305d1f5315b49c72d201b1ca696efa0e9dd36169617a38608db095a13faa61f5f2017149d08de54d4d652c96a307a4875a4f37f455b0166334f2ae7a22d3ca15edfcfee6a2289bc00fa1c567d35a0b8e333ab5d8ffe26a52eb10cc18b9c2fab0245eeb7bf198c5b5bd101da9545815f0c31f7b7c73882d3cafbaf8067cc8dd6475b9f40114086156c584ed79addbb4c8018db29e98a8cf19d187ef19fe78c545d30a5fc1aa6da8bc5cc101e1576c6cb855086", + "ecc4296499fa2a70392ce548124328eaff43a11af95de11760378f2e5233e4691a4c3fe2db4f17d875c5a6fdffe2534d388a482b5aff97a0f9250d2fad6cefa2dce2b6b8c7e6ece476226db19b4017b02030bcb3040ac1f8a9010958a511aa63218bb6d1cdcb89b4b0e124bad3e00bb3649c34f1fe8eeb352103a0b45b4e1736ca4dc3862bc716e01929afe6cf42118c6558fce277b91b0c084fd01ee5edb067854afd0b0ff0aced9a1cd1185842eb3ed8607d58b2ab2efb5fafb8e01cac03383ba0319bf9fcd80438a7b280ef4ae96da3f613a47bfa14796fa7be3ebdc94a3e9cd0954fc3f1115c82319bb97be42dc7c2be369b8ec4cac7e5f8a8007a48bbe", + "2ef8e464e56f85c0c836880f87a54b606e9d85c4cd3ad036e39bc1152ef0b9953705c2faabc91272a6f1960d15f3fa972481ede46d682fb827987abae3cbda39fa4e483a1eebeee3bf60f3de1de62017a44325b7ad178afd9f0fdf353811a7af27b8abac8a6ec42cb584c0e4e43bb2375fa057fe12fe9d6aa7485bd02e760896234a70f162f4f271f676ba991923e3062f23cc81fef797ccee9091e771d1604ccbad395121e351d4911062fda967e6740a8f950c73c6ff6daa55e5393e104049fd4f7ae08f0964423a6a6ada942f8fe3f72635f7fce8f8526e996989ac1a7e1a2d0b1db39ca0b79c183148d7fc4c0840f8b5f10cd31ff9db1046cbf65110145c", + "ff82b6203f175df1105eaed389cbe9b7ad944a6a91d7da540fdce58695e7fd6993d8e8e04b40afc2826ddc3d8b84e12ff3e49cdb71decaa05bc8b826f9e9b21d12f77ff8e7ee9b4776ff542269052efac183698f06e994cf8fde4937732d3c86ef5ccf5e886496c448955157a86cf922e64c7440200b025fad3e5851128d4bc3892421c80b68fc8ce0ebb15776f8db6d217e8d3868496e22085deb802fd24972a2f616534a4b538bdea112afc3db51169a9889c3002c6d14e9ee1344c586e16d685847dd1342bf57b21ef1d71be12436da6c90592f39c71fb695a1b7fff8e10e08ed9fe4d1c2703d1fde0b2f194c3b0e2bf1ae69005909c3ec69d2d415fa4af", + "bd8710e315f11f157e3fa3068e7b2b98a05d3f323b0b935b14137fc97bb22aef955bd199c5c7b241629aadc84951b1b9159856f7f98d7fa34543da6427f9317663eecafac8f6d90d85dd58d9eac0bae4d9bcfd019a9c632f8e93d559f00c2097e27121d99009ca964315666337fb9407cabca840df7eaf474c10c4fb4b00f199c23148fad1b74df249f2f819c538327c5b749f975858d54d384f29cbf333d16d33c44c48fe47ee528b3a255da8333592d7b4bb4241b0cca015414166a34cc8e24a4e83913a4af41aa5e26450f82422246376c36c38966e21ead659fc94105ea9755f89288bb55ccd428c56229bcd5ab817b0193f33527c2bbcf3e385959358a", + "207e864d2b5b919208faa75cbc94763055a0244767dd16e9a9da636638298b914e662d2389d0278951522b20ad8699e111e5eeaa107fecb1c29ef964b17e3d270bdbf71365f80be2c62e0e29bd8ac70706c4080fdf581a3fac006ed7aaeca057fcbfc2c71f3de6485035e1a363bfd2cfa5d5c71ae561ac21ce30802f2fdb915382f161866a82778394dd11ee27c020f83fb8ace32b8be8ae7577f4ee80cfb97657f513ba112eed5c2663660adf04a3f9e69f304ff6b8dc8d63d31703c9e99f1034e75acc89eaf76a29c6b1591995b4df4c1056459f56167fd7c93c786e2f89187838ec68adfe5adc18fb5cc7900e7651c92b7b92837c255c97522c02db048c45", + "1e75687a82dee952f9abe9b065968df6f57d9733b91c609637065f824e0d0e4df53c8ce7a612cc3aa66f88482ef58ad654543c72114e7445fe251b8202c8a21195f1d475417a64a661969120e4b0a9fc0e5832db30bb5e135da37f25c1cdc2a47e8b1445921f44cb46103562235f4469b5e1c8c4383d962550d8315ecae3a78e911923ea835c7868afd6cda31b9a95694cbeb4c257e9255500fa73a640fde2e5d8e02f1de5a57d2679a55a1d1a10c9d07176d33dc12dae21558370f4db004b855e7933da380a4fc8f096023c3b5fa605b2273951a346d901860bca06613c595fa97d179af9ea73f8397ea43f3f399650ea557d6bcf607bafc9eeb17e8aacca37", + "2a2b89717afe0e811c0e1878424963a8695f3769fb81d178257903a2fcc517c8ece1b5b0ca255ab3e5a03ef4217d171daaae5a05d3bf022a3c5877a49d7555c1ff5c36c3df5498a46618dc0aec6e53bba3d29963c7d4346ec18cf24e358a7ba046ebdd8e1b6136b1daeac826eb9a3f5a1565c5314efced9241cf3d8c53cd322da17ad7ba8afbf1d44ea1a36675ba81762252e90d677993bad54ae0434b00bc534b98f7112135fdb21577215b0130517b378b668ca064069cc63fdd3bbd8b7870af6adef01ca7dbd7f8e9c20fcb83a33127f3c9b5b3060220585d76db745472c3766092163b000903292f06bd6d1d17269ef398cd95c1f09a623a26d57bc4198b", + "240653255235609407048e94b375fe0e001d707b7d1ef3cb21704b91edb0ae097b9dde083346f05663b455a2aca2d914643b6fff31afca78d2a14b981604a8111c543e3bc71af3ff9ad08a0871bf395b46d1fc99c28891f115c24f3f79f19c7fbfe6c531d49b11e3e48eb5cfa154b828ac495acd5cabdf2dedb154cfffd5a48ebb3afa67f7bd99f6250ba603aa0c57db8dd36cef70cbb97f54dbd7063876d3f4fa393218ba7d998376de7942acf0ce77500c0c06401b7daf776d3b09b3fca91b0e6b3bfffae9faa4d0dbe0e3c243038e6271e5b76a8ee3c1e784dbe73a0dad499217347616eff787c1f8860d4c75f16bbd2e007982afd52f3637c947a41fa05f", + "12a06bbbaf93f3a6a3d09df65ead7ee739a6b3b56c67e419f877a74236febbebc93a1ab3d8d27ab859ddd48da9f7dc5956e891a98309b5f4109f47ae351697b6cb0d9aec3c81ad41f2ff6f6d839ab6cd74d6b3b26d16a8b8754541bbd2374f386824189276d2a7086444c0c422192c6ee308e4da0aa6a136f452b6f367be82aa830b589140dabd59b70bb4b008d01d475ec1ec9dc42515c7a2263c18cefaeeb65510473fc6340c9b6d963ca28617f16cbb4489157d5ff581da8cfbd0ba00ebe578bde5ab501a5905d8f4d8ff5f111c982b56a38d38de7b4c27df7b9f8e7b1760fe2419398c9e55f2696758feb2d6f460518f070fe3508655c4d478e202014e4e", + "244cc1c944af8f886e2bb0c7cf6e2934aec144d3d27a7ec44149a70a44483a3ef7df64a737416dd8a2db469eee023eff85a1bdac8cbe011ee30a3331f9b6c811af612551b40225858abaeda1f8233e982c27ac4238e995f0cd44244339c742367310f645e54616bbc4277b2c4e712fc92cc780f0da098443e7831c76805bcc8b6fe77333c86f03424034d39ca26f0d60d278be2475af4a9a9142faeeaae5212495ee0a9b98526a2036a0fffcd397556caa7ce55313494328939078944bd356bc4a0b0b8761eaa4f9fbb90ddb38bb668d679c2abfff96a4eba5e81aa73fd576b07f23d2252c1f1e2704fb171b27323e478ce759313802577cfabd04fa36541a37", + "16a319203374e5495937c4e8bd1c6db659ef76cddbee2a24d4f518e54447413724cd0bb7584de828bc854e3e722dab7f795650b0de4b057d102659045578ca2f8e52a69124c808a233602e23da2e523082a40486046c176e34ba8eb318c15aae27241bfea34642c0530de3a425249b651f9c85453027a3db5e1bdc174a8eae597574238b1e17a18ecab2458b54eb03524de5e48a0c1a9de67ee0e493a39cd84fe7a4396beb3443c3cfff22406761741e70dca28c7a9d03bef8e7eb82611a6d1e423474375336015c4052baad4f885ff4dc91f4612141c1cadd946e2525e9e49c6dcd9bc03f94327cb3b6fa9b7acf45bde40616ead40091c0d976366113b141ce", + "2aeac9eae2c7fac0e12751d0a46b8ff45ce529bd42c6c38504e10baf5f8c8f02c5ee031019b0c7bc8d70b51ae57b4b8bbc5bbd630a252ee019404b87651ebd915609ba24b3f7cd94d5d3d55f7fe175973f59921177f8f6ed8a2073f63529736c1690907218d9ca8e123eaad40224c2a74cd8b4153da945ad8fb1ad03ed1cd7ef5ecaa7115655376d934aabfdcedcc14e0ae09177cc28f62fbbacf3bdbb9905fb8192cb51665847ce222c487d9e29badcedbf5c8f3dace408fb00cef033a0436bb648db2f48baa56eb4f8fa153e8c49a5d63d8186d2ac1e91dbed95bfc40de88a0a4c148b4c23e0e0ee8b651054ab89d5703e6b097117a1381d5ef453219f4704", + "17a1ffa0dc6ef6be0ae545bc7df40b00790fbf55429e5762d6afbd510b8972f079469649c2998890d2dd09483f9c1c0c14025b2fae0ed30eb4b3c8c5acd41142ce4266661fd1d25f2895f1400848f3d845d9d7cc4f032e838eeab23b9d9cde03c8b89131fd19a2f8a4553720fb28e9521e39878be31af6afbb74607cdf855be316dd252b453fafe1720d74cbb7f97d7b72d7b6dd4979d2c4055d7dcdb1d39748f06fc4f40490ad8e134e02cb68ad0df2f5ac38fe513b8333b3ace221fbf845c43272397a3ee1734cefc9143036213d56101eedfc66f5754759d5cae937be962947bbc6bfea5f05aa370616eb4dec0ed1ee1d0adf6ef32acc593a5a36209b6ac3", + "f0c22ae2b9b4833a3073e5dd8f3a29b0c006cf89095155731fbf3c2c877209d67cf83729552e8c0c9a1fcd4cf30e75946dffff28d7f2af7fb93762b688ffae3a608ed37e9c0d2a48fafa4e39fafa2755b879076bbf704cd315616e0902eb650f16e84f1662f977d0bc5068bda7793ed8fbf50c5f4c99cc342a5fd7c7bc552240a5dd82d2dde9ad0a2c56a53557f87e4acd27eadb531eaca0a1ac9d7d54f7312f2bb3fb83329733932003f64d88ac90476594405e3bfca583bc7ffbedb23fb0c1e9e896e8794fc61592667f2ab22c658f72bdf60a0f6c7519b383bcf657e61b10931c3a29935dab84d285b829221c80f5ac9737d022ef7a127191f189f8f00b3", + "8afcbfcd479d67a84d69e8e15d66245ba69f7d483dfc2b8d822934d16f1e630fc4bff4cc6892c8afa77c96fe786f8ec9dd485fc7b0a8ce550980e7e4086d98a6c00023ba883313a3082e86d007cb75a254fdf9ffe881b3bbc88ab42cdfc4afbe51018ae314896994196762b8bc7acc84482033bec2ccb49382d9f2b767afe84d8c82af7a12108d116b33e2276b356d60962b56aa5d2701ea0564e1753b1df21801f08cd5b24763c2de1ee30b78078c17f4c9e9aaa9d19a70fdfeafa5f72926497b0f97117461269bda848199d1922f1736a0706cff982e85ec8bd6b9dcb6eeea70181e32fd965bb43316a6a3382d7f6962cbda55381137359b78cef537084a", + "c5bcea5b2e6d6663d3d0cbb22ef4fb683917f4897b82229570c5f393189d8999fa9c7b3f661c0cc29107a1e6f04bf37b13402a83bfe843509df46e3d069c2558ab6bb96a729853fb47cff758fda10851a65d67430c58b54f92b369764539d6ce4da5f40645e2dd42a71d0bc61451e1b19878e0a3d46cd46934296fb5e73e2328aef579835990a4300ed74023fea83fd6c63dda1fba3c693b10031fd1394cae21b2474c36e8568109f8505d0a25a32be20f06c573eb0587090330b6889a722cad7f7b2368f004039dfcac9a67e0907c9423a9003a5a308ce6d1724473eb73ad915bf8454914d80a92aabb3b4a6379826898848c4f953f0ff921618d53904dc2d", + "1dcaa7620c3b6b41cf6bc5f68ce61a939112f03eceaa12cd0d7f35ca95951708222c85fd707cd84e5d0e1889d55d427d42cf767d8f2398f7a2d7e67fa7fc706b5e3147e90b8c10fe0ee4cedc53cd66c5b5ea762440f0945b62eda81b7a43fcbd0da5961ba62754404521cced1efb1f93647a0f9acf53d3ff594dd320a693bc6910ea98dcfd9371be641068c54d648daa43b703ec096845f4fa90f373ccc404a5b948b60af044f9286345d9eaa013c025f52c09ca8472306c331dbc08c30684f23d796b8124d36743ab47876d15bf99a6eb441cc807a4cc5f5afe61dccd91b5d6f438ade4d29f1936aed109982d7ddcd954aa2b03290421afbc865bcc6ae1ce4", + "ff56c586c321eaea74b9531f49dca801b3a8bb673bc1a01fd5acb594cecbe48f4f96248b48feca89ae8b8d748778f333b9d7c97a2d3182d06c1c7af77839043fba784703391c4d51cd7af513c4f10275b8d5e2ff536a7a84841b65764ddc5d190b4b9922890429de173cf98263f6375fd352f0a0c18f8647638afa58cf067e84b4e1ff487a3584de307a49810e999bfb3a0c3e270acfe00f8b12f5c7ddc7c7500c9e6c3772353b3033b4a4ea08822f8888d321c703caf661351d4bc7d7182dfcc09c78dc0e0427ab604f6377f7f275041d012555eb6e388ef39c79dc6735ed32740462ce1a37f9df332442600f09dbbd3d7f29a7e694dd457da9bd6ae3b34cf", + "ebbf717af4f8a60b8cdc38c349231c6fc82cf9e4959f0a9031cf63a500a1d9b8a09948db11d810f68cdaa2091919c673df3370dc9f40c2c78c60be51777ab98f46a9406d804f69b729d51b45129b7ab03896886680ed34b7562c6af198dccaf1467356922c457ed4970509f42d82fa828b47dd127f5f3f5958efdb8a6fe54166e87e5e702395268f8f75ffa109bd9bc059a549e556e7069fb0837c50759e35afadef8ce574c105722d5752101782d3a06960324a89270217a5e8db8f99791624cbd302b195444e5f4db3b2cb5cb35b81cbcc88cee9eb9939e3362e67fa9ed59164779a8ebaa0eff230425efcfcfa40e90a1a3274aa8cfa7af561db4760cb348", + "1c87eb1159618a0023935aed0af77b7f694bc6012d7da64e831daa41eeb23dc0c92520ddecfeb6e2feebfd37fb8d8873c2bbdc1a1c2ba33127cedeb3f8a3301b2cc158fc4038e2512b5f41560928b629e54de34d4aaaf325d2b9967617e860fab22fae5c3eaaabb805df94d372b3fb6605e1b13caa976edea3a0f1adc997006b9954a3a3934e71c7de282546eafa7c1799500f1d8a7420e2dc81160080158604550ff03fd99630ec098433767935cea0fda7f58581d932a718701ee7db3aa4cbecfc93d91b1ce14e8d201deb2c82794534d39bb4729c55c32d23fa4795f25189bcb66f3abfde174e1bf34b66d8ce33a2c230f4470df5267b14c35512451b1699", + "2b5ba53bdf3ea9a6917a27d7fe4efef665af0a55f6b2b8762fb68d00cbf1b86df00907fcab406142a5472c64265b77e92e04a7efecd035dcf68acdae1c4386d69ec8d2f55e5d6abfad9b47033c2d813eb58c83527034140f67a34bdcec077f1726a40f35e3647fd0d7a582ba09c7fde71a803bd699e0c4f437988d4d38e12d51888d746c3fda076f27ae87586006434c1e79d1af7ae796280047958cefa9e090331641f55c734c7b5ede7b5c0d297c943e52dd2f618fa6073deac1a1ebfb064094942b5b0a77e98b69cb105c00cd17635853033d574735cc47b7454591e999195462b7d51f88155ad96cf722785fd024319ae4f54d23241cf7c5dbc9b8aa3bba", + "1e97bc65c9b42310e3fefd487b9dafac19dd649ada08954aa17a858195d1203b128adb37632719f3c916e70c00f886dce07726f43a0f6311c0a93850c97cf48b38101f6799a719ef4e299b634766870828037f8b01ee6197a9e8941a3f27951e8ba082391d8058d94f5c3cfacc8bb0f46f4f5e6cc748439d2a759c206e9396c8e91ea6a73544d37a5da86e8d143f21dd5577e49165b26b8a5609234315edaf9bd808bed1a87df8a5e36e9678d6fd5dedb79f5721c21de5737d9a131c49df5da2a15dc77b9c88162f4c0d47a20f2908983d065790c7247d09a356f208e91a7987ea94e0f2e7b6e08c39eb1d1ab4aacde5b554afcce48122d07bc105d78af770b9", + "1c86838f900f4c2684c8c6c38223c4ef5bc5637712653e3020983c9e2075e13a57b292c804eec84c6248c1802a078ff1e3c900fa0dc86e8bb46955286b5e9463922f81192fa7ac7044c6c3068ef55d815101e30ae3db1e71474a5dcfa0f8101e7bdac7d3a8c10ba086f21e4fe0979b03cbbcf906611f937c93b71d1de7bb915078637779cbf80dcf6cca7f0fc18e40b0175e2015fb7e1af77f7d71f0871a2153fbf81a746a58ac62d363bde4efa5c0785d1716fc439d2d57ca5b38d7fee544f82c253e67a1cf604f707b705df5ace49ef9ab525ef054d3b2633422a4382752e4b7c944876fd8326169f2fd58662386217f46d8d7965d448e51f75a1edf4b0907", + "1f2d91eb6020f5a2e1c185eb58529b70370fc0e8f434f44d04933ddb1e3cc8da0ac682eac03c81ac28c610b6221485e21ae8471219ee1130c2e0499f9abf0b05efc7c2530e94d2757cf0504f4689b376c57a7e9bb6f1f7474fbd4fa95ead3196c6c0ad7ef4e908bd618180e839d24caf12a47f035efda878613b43a3dd5105e2a8f0b57602a4737bf2979a2117db793824cecdaeaafb3814d80b44c4a240716190b1b13c203ee66b8e4ddafb7770d49a03b66ed9e2e145c4dca27fced19576b895980a4beaca14aca1bf78b09d96fefe81366c260329ad9ff9bf6c7b667db4885c0f62158a036b46a408282a1263a611983f2419ad1186877238410b5ea11421", + "76ca7c33edca9fd55551cc46de56270193e22abc886c20b0c1b3d2099ce118e52b17b6a57face17aef5b688975cefeac5e5dfcc76edce79e20cb62edcd5c0eb8d766d5240ec47ded0f79716ac2444dfc1f54ab30bcdbdf14dc53d19ccc1bc534f998b7f426ee7f8f454d4a11c1edbce2d24d714ee9f9993689fbaadfd579c9915da2a6d6ef56e61eb4166e676039d61df2a21d7421166e91ac19969d247b0d39c31355ba4a1dc4ed44d0865d0bd7dc8738361404a52111f0f2cdb453567895b443999f99d39b7bedf6c0928ac7dc21848dd54010ffe6c331c87d8ab25f771cebac9d9459da126a106f3fc9719cabf1ca8153b55d7e1770fad22b4b02ac32783", + "4c2baf3ec7bede479c401bd4db14e28a5faf32801acef571b9164cede48f33a85932d59091c8d40a138a69e4524bb583df764ecc57f62e26274365847f219d45b64cc125015771905ad416db81a35d7ed719247d865636ef8e2b2f4751efccf57b679b3964ad48a46436a2732b40dedcdf6b7dc1ebe5cad35e85fb85b703eaf036c76b074ea20576d9584013b58a49c81d60b29216b860f08539e702ff0700509e5063c649602213e8ea14b103689bfbde6a0ad7045cd2d524de7eaa67bb46884695c496a96ae1a5b4883015f2ebae25e10f3089b19224b6d748364edbd71c82f647f1ae50762ef4ce4ef081c8ee41e1569d3fad8198b78869b33fc5085bb23", + "17c36852c11439eb4ae9ad073e3314631567f18d681cb9f729d7dbb249da77ef6eebf34e421fb7d0de6d4d6b29741879280b291bd973de3c96e2059d9c7beb8094a308bfe143687884e44c5501254bdedb9f404d165fc21d6979cef1935092d9d2ba0fe6f894542fe49f6ee407b260bb08de13864300f6ec848882bd197729397c33a9703ff5191ee12119ba8b00e7a9f58c2d68c4741bf0f9f50660408ad562faf06d9d985e99116e9dd54905e035757a8cd9ba9bd5ab6d222ca116dc90500ab48b2acfd9034d85346ed08b5e67f0dc26760d1ea3b9b937afa5c26c03680c68d9a65b3afbe19fddeb0adfe50dc84d33cd771dd90496771223b15545eb8056ac", + "2dd1ce888db7fff89c9976ccde17b84c61e3cc711a68234f0458c26c189822f1d458840338b6ed36bafc3a00a01e69ea37387baa9a19f6d0876a3428b6a4d683569c28724b8f17e8edb1ab354014a9f3b2f4268b8b5aa6e6b3b6da35f32eb4f9ad76862f1a3bc4ee1954efff3d35c3dce4f9d6cb8ca977aa21fe7fc98f94b406ad267341228c572132cdcc431b4f90a2fb7fa31a6e4bf35dbac3bf0bc13eaa80509aeda7853e1c2b0d59d7cec4976c1814c44c0b214d5e2ac49f3528b3f085cf3aceb3a563b2d0ef64608eba1379d77856e8feede16b9116d90031ba2b684c80f5ae09790c3cd14c1d89eb6d6fdb687b4204a54a0991340d2320084b55ff8ce3", + "5d5936576e332dee73682b0dc0ded67d4a6a7df7c4617761b7cc00ae0b1cea5728a7d00ba837f6676b979e6351d44cddf07e36d677f7bc25a27dd4bcc6ff1e38df0e8d1f70613c243ce72ccd4006b57a709b66f84be6059223b7d5472024dcafa0ded3cab46c313d2302aa8369641f1aacff941437fc5f859645065e472c3d3c9a340e7450d8058798b50b5138ca7d20a06a56c61dcd02afcce856bf18a1513067bbd2d2c368c3784bed81fca0cc69764fbf52fbd436f92eda399bbc451ce1b8ab8c60387c249058c37e429f89d91b8fa7329901e02f6607c15259a0f1a51531f451338d5719c6a42893986d6314f7ef7b61b0a9bb492eea59598798a7a2b6e", + "173062506020be8f4be6474511e011cd647dbd09854e2e019f24add9188d8b4884745266af6366ee731e33b0a6af6346c8d87a48d65a80e8a523cbc35d870089a7fcd4b05933789647fead41c5e79575f0a781baf254532b24ff823f07ec3bc7648f3f5be8aa17851c27f267902303546bac438a1a765f23a1d7fac72c0fe015a249048047d4c950fb81ec51c99539bf02c67698b050198ab45809d79644aade827c3071f1c58b9e7bde0074cb43e9e09b54bad0a1f7762dd81ae65f1e8a2650538f26e629642dc73aedd180b88e0f8a4fb0da9a20848a5ab62bbed5ecc779db560d3295a4d133a8161ec4f4c0f1003ff0bb5d819e157f01fda70caa05a9766d", + "10199e0698eba7d2c98704b3d285e14a6e33ea5e93f16757276f508986ea379b878ae8879c359f8fa12e9221baf90cb92f0cb7cb27c127722f58ab4066ff0c09c150f422e03f13c0e5227269e0665bc25e0291a29652f775c034f40ae3f8c6cd8a2c1460fa6fa81f9c4fcba84ec0e605f0fc5d75a021418a63ea9525fcf350ae0172d4c3862f3a7b7ab48329b0c7a346b08ab591e728604b63632771327040bc71e988f98398fb016cbc737679ac9569ef4112a06a625e3ab96a3cac6beda10e76c9a6033b69e984ee0be1fe562ca8f1a11614d28086fa71d744ca723151e0f18e58c23691b4b79fe60ad9f570ef67c594fe51619b242a018446de9cb1ddb417", + "2488132d171641d6becf842f05dc0d0b35cbb2e666c7819dedd9f396de749d21ca579bf437c5229d7767d8df7128610ac1dfa41392474b489eed084350e3b992e4e499b93d2e1e71bda0e336558f9c365af2fb1b053c8cd5ad80c538959d4fafd3a4d4b67936fab453185857eadafefd6b846dd31f7905c8123d7eea2c9df626e73c4a768eae9f0112c9ef0949b462ba35e40dade327a168dc568b5595ae15e63d15d592b0008aeee60a78fff11b5511c39a08a7fa7c3ac48256452b62eca7fd532fc15e97bce2265aac3f6d55e1a56409f6469088324b1cbb28b2a998f13f335fe69293718d2034fe9a21f42f53b7821f5f07d1767f453beea158446777bba5", + "363e047e92b9b323ba3b5fe9b48266db9f2800d40df6b828fa8115d7ab8f6885265f41736dec468a95ffaa1b05ef7da41a3ce92ccf5954a3862392b4bbd6c12fa8d13eb05e7211df97e3ff22d5cb17975db94a8b0986a1c76e45a67bf09c8b6d4871588701b4065944ea53e076ada51e266bb9ecd66a23412fb4fe8952c8bfd048cb1a6866ba9365aeb24b8179c08a82dd169071d4705dfbc08cdcb96ea709827636dd2d0e262e419f1cb2ede2e001715584e0813d548d7f3140e8f1f78fb5772123f676e8ce49576853e43b7ba499485fe0fc4b5cedaa7eb2ed1701af16ab606f595fba90ef7a089cb5cb929dc1ddc3940973cc7a3ae28b3be017ba42b4ea59", + "53287ca72b60f7faf0743f929d863fdef06bae5c4095670b92398f69c18c8f0457442a871c0ead210e719557412309c1e2127de322a04d3a8e62dadd4bf36d725eeda184e475a5aa9d07087873e0d9f917c06dd19ce98823711507eb1709eb55490f7ab5150df0a78ca2c29d26b14382c0b02a1bc1de66ce924e25ce13b110cc939a033158e333988421533a82ff73f5c5ffc5acf9dd169802b4abbdc56d948d201902cfb52a2a2dc492b996c63a93fd6ed7f21229c2a126b8b6c14f72b6d9fe697358d261ac2674f8e2d8de86d21c25396755c17b7f33576a49e49554c45a3e87d022eaff69a0838129fe652c43844f4d9fedc3bc4112c8a1ee199acd956e4", + "e644cf585c0d4f4d6b9db2809e10c29a77fd1fe9b262453ac52c3df1c993b70c2cd7c0993d8103aea4b137495b1adcfb8d8f2c54457f20935c00c352af1707036eeb400dba19225622357e0ac32cefa3a02a487c108c23a2b94d583a82730a37574afab7a6e534d848b5e987446d9255da8e489a5282eb07994aff2550b1393ae6a6e7bcdc3740e8d0d75f2e17c3442df89e641a54c1594437eb119a1552406e09353953ff7e7a955176e46940eb4c05fefa541acf82a0b5f4fba53efc0e761dba18a51e507a6e2db2517fb62d19e2f0d827f5852c862772ca19cb52507fef587c32f135695e49d3bd3e55dddb886ed1f74056e773133c72b86f3bf6d6aa1e1", + "338255d0ca95f33c63f9fbb606bad07972d80e55d6400a4780fd324c59c3fec36b76d49d7a17a5c0bae83e292693a59fc897098d3d63c9d3d5dacbf0f20c0ae32a66c6313acdff59aa576c11899f2a3bc28aaff696ba63a08ddb0fff04568d20e100b00061bbdb98d3652c296ae373c5e4cd50f515b4b3b67415871eed525bd504470cf9ca470fd53f461ad5a18a56044a038713a82e437b6c072ae46031306c6121aadfba7dfd063d06f321a53ed15d1ddcffa21b242e0c8dab055d85bc324f84fe18aac1d828feff87ad8975bba735f41540303d36d8d881188698af28db2f577e960d91a2f139064ee8ebfb2e5bad58f83c021f6725f42fea55dd8e29032b", + "4beecfc6df1ff09d1503a8f970ec2b76d85b5e44c75ba8867b31d8f325e9d04f4f0b8e29196c55e04194a0a550777dd0befcaa8f51f740e324c58c9e798aeafd973ffb1386af52db7a3bc8d9424db65f042b906f84194252944d88d740ea6a3753876004ebcbeb7e20cffd030f9a31f4f7babb73189838649fb63cf75026cc1c95821090645aa2d22680c9441f824e10e3edddc7d878ae0f4a34e97260404cf0bc6606eb0985bf0c194e88c63ac5a2220a072e2c8de3a262561840a8c96575da521ee379766f9749775603cbce687cc50f4b78ba6c8198a439e91418c0f251fc2070b57ef292d2e8cd64be9379ab1fe7d3cb0c051324bc3caf43c87e7ca9d63", + "33bfb627aa6552050e507f2b59ec3b44dc82d56caf1246dd5383b05c4a4e9ccdcbe11ee487fbdc9a2109e774681253c87d5f35e2f0784cff161baf72080b5e80c27eb60e6b6ac76701bda612a821bd6519f655a976e73cab7770ea4bdb657b7d2d11b010ac1611665669d80236c295468da283b8555a20a254dc9dee2fac69dd7ee829f9b49366bcc3d317aca0a971f6d1754da6e9800dda0996eed04eca07bc85e309e82cd0b48fbdf3b0a4cf30b71d7a5078671ce2f18834514f13b44883314bfed949e8586935f23bdf795ba47be3953e2368ef62f1b3283dad0bf23284ee29367c73b76bbbb73d9fef53e5e60ba6a8d6162de4d1af2837a4a6a7a214f2a7", + "14dbd6f656d960c6def00863749095b308e305a457a4f29458aca8ddea2ffc7ce4f44e01b02d723300a4f7c35afcd222003b254c49147f4b751367aa067e038c2be19fe867922241ee6410828b1be27c85ac7425d4c418d989e45b904cf4afe9623b7fbbf3cf5aae67e522dc55f189ba31734f7efa082367543be27e9b74ca9285ce54b91da8ea5f19fdf1cb594a2931b067d44b2182944e190adb0b3799670478dd565844e7d7c1658719f8f1c950280d817726e6bd5f3f2f14e06c3b4262220383a6e72e934fe6e847c792440d5c0872b3f2d9de834cf90cd3d1d59ec4060f8d0cd125cac6f3071171bbdf3d999aeca62e391066b2646e019848f1a380ca16", + "225bb3b84c04b5e3f74400256aea21781f3a0176a3472e18f96821874c7d66e7dcc16cb74190c85dfc7a16a776557f74105656863c309e87924ef2e185781525af9e113eb237a899271996da6f13af0657c49c7538cc9863cf8b454dcb81f7b72322323c7500fb13ee7aec21943b9c0cbf12c4447da8764ae1928d69a57280b85c3e62a2214622fb366ec7f3899fcf6e5cf5f8714f9653c8d384eccc3a6d4a4d8f40731c1a9065fac9e80ebf5e977e1c0f9b349f49119115f4bcf0671a30da485bbe66f5d8d5583248c6f2726401ea68f4e1db5603b296f67b1d4224d8f009889167b504706dbb1af4745f005e80475f20019ddc564be71dbcf78441ce131a95", + "783510c1864fea24c6fec9edb515269396a6532e6bbe25eb1929d16434b98ade21a5f1c9cab0c2a2e5c8eba477149e1080786d16de647b713a84280dabea423ba4a24b8e8f0769c6a57838c545fae966440a242f90ba05572a3194e41e8fecd522a1eb31c2316badb5067f1580d4f4a864ca05f3479db08c21d1ec3236185faeecc143842eb7697d7729b0f0bb148fe9de6f5d9f213392dfa1be4dab237c127309a03281ef88c021f2b38aeb3268f98e9dee4a055647429f2e32318b6824236afb4294624a50031db296f8a1b651871c66667cc6e05a1b2e9a03613153c5400671b73a025426e41065e54bd7f68a3534fedaaf9b5471f8c3dba4c5aa3741212", + "34ed4bfd07d3f55d58aedb608b6e3237680a258c46111cb57538fb55575061a1c9c9d20da591f9c2598af8673a84ddc89b129ffcb1d9e05f2aaf54df6e140b017ebea0aea9347b7a21ad9e81a14648eb0013e47d26852d27b9b151f8b5d21cdb8fe81d1eea6ebc7ebe899d55f631b514af7f73dabb96ec000ecf451fb96af183cd9674f0c6298fef2a14988dbaec247db8e6e313df34115e0edd312f75bbb1adb6a5cab68da0e6886dd2cc8ee6c4f4642b2fff2ac57307f8a4f396ff076bbef12c22b5a42ab6a0fdb44cf57e6760a5785d20ea8f30b6091c1f285616cb63fae8e9cd3e8cb04f6d2516edfa2e8b10237ccefedf9a4430b379cbe203bc4aef1fc4", + "33c1f613c783e68e53d36114aca6fe33128b4e6a0b60274628c59edc8f5e543c2a07464bbbfa3cc4347fc727876854a53d31156fc20b90a73c5e1bcaf79c118565fe60923fc108a60f24cbd10713b1f9f7b085f78153a61cc4d51bf366413c59ef811e9472f205c8c8a1f3af31828cf159b42257c8411dc4b0a320193ac0d7e50e734f7131f5c8b546f628610b1f9ccdabd73aaf20213a2c40f07f5201733a74969dc7372702b8b49a4957c5d874a953edb95544cda66b3f05dee0df7cc51ee9c0acc5eaa4ae7e107e5512c8ef00d6c5298291132684ba0488b70855d24226b6e99ed96d6a2ad2e64561c2a8c9643661dadf756b0d0fd0795145dbb254a95a7f", + "2e4257c3cef92b5eca2deb71df54e630bae87e33665eb6f36ee70e8e732c209befa97b76cbe66225e9cb2f39a6b5453758135218b25b5c0b10ed0c2970d720e3d6caa73829e9654a2c703bd2f1c360ca2176a40fd26bc0e8f3adbbd5b702875f6d5a96fd0eda326e077d381fc26ea964282864860be5b73e2e553d30f391b7b6eff497f701dc2fa8231d73b0c2bf09944a098225096f367a8d52b663ccd7d08ac8e4547de1ed703714bf148060886c6439fa5b3244786a2e61a8dd9a7d96cb7e5476c7d79ddab0c3780299c106407bdc0232addad67b8f4dfc9160de3ea1e589fcd03a20f314ab3f2b7232ba2856f2acbe83ca9cd05058116db0dfe0fe8d1946", + "35fc40ae464ca72b795625dbb866b027669dffd9b3adf409f841ad49ab9dfd05dc61ea25d9e25e8c72bbf4b4e037bfff73b22b8730fbcf2d6a0cca1770722bafb004a0e76b29e21705f58844e6bbfe41ead3fdc980b286611c45c4474664459a488f8e45e2ae9f6764705590c83bac68f1d56acb19f63a4641c34aad9a564a7b63ef0087ef1d030b68bfe8aa20f79c7b29950473421a2cbb98409602c053d2adccfb8e2302daa24d9b95406cb83513eaf5072fd7bac51c46684d7f8c2e5227fa13cc9b1f6c834c988c47c698d7dc7e67c86a8c9455618b85378f9ffddd35bbceb5ff3ede9e5ea0c7101aca8f4078348406dbc657fe8d5c1cd3148352c75d7b12", + "1740b9c53ce38063d25a730486a06662a7ded0a4bcc69934362c287fa4074d68f364e1f14bea650f74467057aef3711303859a6721e1eb8e518872de538d6ed84ee000ba174af32d09ad25a9d9deeead1b8d8870e7199f1eff710faf548f18163ee52d383fb332ce57e9bfe08441defba86e16d3555c917718ecc77ae83c7c7b29955c6aae768e3b87b46544cd212760acc15309d8959a5d7b4dc4e1aac0f57df0e788327419e8727e9ee4751df9550cd7efcdd2892de838dd115e0755871d3b45bbf9e32bf3e99446571ca713594b2e97a35e0bf12009445f3f1d025dcc7ef8d2ff95aa109f5046af294cc91b8c0433cbfa5dd2f842ef0f844e5077af66f996", + "152c2854cacc2c0972f70fd50bdb1cf76d03ec4465f822448382574ed3879cd2c8f1a90b6b7b0acd1be5eab9dd980b568a046d94346dc652df504a15b55475ba628a3697280548939c1da08eb61aea9a575cb12cbe698c61074c95393652adc032316b42e30c4345ae4b4ead710610837a7c3cea5521b0fb20a0027332107ed3db7ec5885a8604cb548c558d46472a59362087cf14ab1e2ef7634bde927b19d4efa351b44b92c170766278a569168fc1ac07babb39032e4ebc33dc985450fa5461f5140e3a20e306df6870b244238d46d6b204c9ef5be6bb1994f8f1b85fb56154ee1c3500c945fa9428b099cb5f358ec5e3b5231bc37c3094ca3b489d6e585c", + "2af55a1df765a142fb7fa729ecf55b2dee0895802ec6eb5ea56524aba856217330e9064c723cf582d7356eaaad9b328e3dd16ad3c9cb2d4c63b72b37217c8eec42f07fdbe342561aee237750e62107b3a4621e9746310b57e798ba55f49863b71fc81d991b901bfc574902bb2e68ef21eaaeafd276bb257cd8b8519ec407bcad92914392021401739a258ffd1a7bc14a5885a04e3b099bf89c08e9e0befc1fdd30d3708c99a2d68e2e3a7103d02d8b9bbcc965ee6f16b5794bb1482c8cae25a1ff77f82d3d20262854ce4a63fcb21471c53427e497d7c3bfc7be128d7c674bf69b9a690ceb6235c1bb4291f0c1d70be144fb1d6e0f3c834d7f988e69469370ce", + "8d84e0eb62e9c4435ce5f524e53e8eac8e90e33d9f5cdaf57082bc3b52e8f36ef1ebbf011c788db0f10850d0e1050fa962aa76e6400341e12be7e898dcd5ba0d95fee2913ca9882aec9f80b7a087ed94e5d118585d8a0952dc4f00be7dec0c95f7b850603fad78b456764f1881be91b35870a5234336b2a7abd03ab868399b711a8391989a555c53d2b06977f9cdea2ae867db8fa4f6ee5e6f4975e16eba51a10b9a5fcd5e10bf4ca4df89989dcda5d1282356272d37b589841a5beca13a6fbaa57bb2a52851cc869a47e7c715710ff2e5dd0985648ed033ccb93c8434105370340827c6b91fa5c46743d5d023757b8cdb41f6749dbcb0b9874a2ab34eff034", + "2e41222b92a606281fa5f58cc0b2d25ee39840db2408cecae044500051a2b520e77fe3aff317243609f5beb613fb46a326605d9a6fa784e861c4d696ebfb41ba0d12ef13129e0fa401c3b08c03e444c5d45190561195e2f5c6425fa94416785f3d29b2eb56bdf8a743e5b4e3166d3f6be9cceba46965c572639d9e093edfdfb6d3c54d3207a426a42115a5ebcf263fe23252fae16906510053d02d7dd6667c17656f14b0f3ffcca1093b8f996fbe68ab82cc08d58dadba6d9b7d58b8d9f0be24bc0aa98366b67a9d765cd9686d69fb4d31e39446a9b9a6959691d5c1cf98c666a3349a56fa0e87f2d17990065845d27070da308745b8d22e0c1636908678eec9", + "410c5f68f2d77e9d9eeeaf1fbe4feccde59d00d1d58fece90ef86355b0b81de87f4399a44e1570381a34cdc47d17a192855d0782e10d42be9b04391af4739cf48f8eec656bd5aacb5563803b308723f9f4c5c979433ded18c3b0b8549f6fd698180ec314b7d8f2d8042835c379d5af19fefbf49a0a649135e5b8e6105c2faf9daf0f76acc880f5c60bd0b242d0876698b69c96282abe95fccd9a7164f3bfbdbb57b030ef3b0e4dd6990e89dda05bf6e266896ce16873030229a012501cff2cecb03293455267c5c75f0e1db438137899b919f6971934409c593efcd3502a39fad08a69bddc0ae053e15d47017085fcf289b8b37fc8c5088d25c5b306ca52844", + "d4ccf7e120d2f1c88adc5a936eea785d12fb4ab480a62c24f58965c0f71b8bdf98e379731ac3bafbcbb5a255a3e41ccce41070b08320b8b9790b45f4633643ce368a9c2699a8b1e5a387768d915e0b87fcb729aee8996a89a15484ee1282dd0493d7045eac4f94ebf9e7ac861428589bbf41f8325c7048ea07de82ca65e8163c0aade2cc1b239bcdfc245ca495a96eae797abaa1ae572fcd8adbc506842a8ea8663c3308f36451634e389fa7c1391ce184bab8bebba4d0e12df42df95acc2c78df049489f616b000e15c6662dc9c7c988d77e4c86007cb2fc0fb08dddb378a621c35cd93b7561836a9bc4deffa0f93f786d4ed8c1795ed203cba9b9aff18806", + "2950fd06d7baf65a3a9560c8eea50914c00aba2390b729fc6683f631841adc625bc4b1e0d7d25a4f2a121abd20a4f89a227c4dff4ed527a5ddb9978b6d35625e049962a3d9ebd44a1038b268d08786243f4ede4e9a44caec5e7e798534b45e19773ebdd2960ea331439ebb6359c2e1151be9ad2673aea5ae9f0e93dc97db356e13e8942b7f4016bee1d8f8db6957fa22b67562c294f337b72ba0abec3de698e8efb59be94e93c7e010b0bf7adcd8ed560f45fa75f4531e1e62802d801d1e02af71abbf54b3fe6fcae69ed8889dd07f8f83dd0aae6de7995b8840e0b13b8e7544a612663a42dd65f716fb70090b954b8a6a62fe838d0ecb305ae26cddc3e125c2", + "116f7c224a3ad4a6f88c4236b34e5b53c067e224c584a112d457fa692a50be688d7c57af4bc1e2c8724d55688c4a039ac5f4e0c5317c8326e8c971f9edb8c884257f75b3f6478f191e76dc44d8d5a1e734de0ccacca20ca5ca715d1576dc8dbf263c5f9987c8d66a953befd535244e7ecaf6369878a2e6e4367f81731e3e8876a16269c0eefcc3f3c24a6aa42806519c11225141b873d5d00694add161a1875e47a9e16e1def6bd94ab71a0038a6cb265879ec6ed8e74dcf8a65a0d413fd9770d83859c0ca3d403d32655dba7e589f485a22a785e68390c00df21f18b37197464436eb9fca8d62c06ebcb62064dff621561cc8e44564c8dd89d21e383f788529", + "3073fbeba1da51dc2d10964138014731e35b61ef9735c6c17d50dc2014d0c39ec99f298adc8510eae861f91cb34bcd28f47ca7fff633404ecdbb609c8a630325a1ccfc35b63f9a942e5fb52db7f7a7a86cf4ebf032aa05c3b540fc21e93bfb9ca8810dd676bbce9be52c4eac9f8e4540de15bdfb002010d757f37891ffa46d7b2592b298eaf33ae166b5ab70e0e6585b89a9cc61ce803c16810fd5d8a15c0a8e07bfbd4e0dc4a283699c545296428fb1a1afc61cd70e10cf12aae27abc8390d1c918a251d6175530bef8e5691e5094b5434e87452d39bdd9516480d70dffeddff545843ea55771a03ad5bb9ed5bac366753ed413fc957e6115cd57c1ce9032e7", + "10434cf0f0c6076edae9f7ead7bc6e22bf12a3e85b5855cc0cb753837d3693d21600edad815492d70e692b88463ca1b1a54263d6c207125b996bb7af26d0555dc4b4a4bc87aa8ca52ee76c5f62892dc5f6576058dbc051d1d853ef7e723122e07505e2a8342452f7b3815da8b1015f60c40bfe8e1201824e76048c0e622550dbe04413e175229cedda583acb312ea0d3c50fdf226d0c5fe49ba2ad899aba61454cc5eed2f82ca59c2d63a810ca497b470896a5a74244fe93d50ddbb7fb60e6e9169bd2293657a788ca3823160b48162b5384167a9668489277c5bd4a3c3ecbccd699fa4568875caa9bea537f4ef3e21710a00c54bd5cb8f89d76a7f204439df0", + "9c162f42e6ee80b2faa9491d4d6045c465b4bc82779b09a2322ee5a3875f04cbc41d4688fb8eb9ef2218467b6b38dfc3adef0412ee69c4548cd79d8a43ce1b4386867ff9d06447da02601c754598defc95edef7d3b1767e8d3ffe0e1f74915394d2336072128b1f7c3bb95d8988725fc72fc6075181698a5577224f1a8df3b9aaace508e84015ccbc33733042c19ea2afd6a1cba9b1a9b8b3d697a04bf4708bb136e76647ec1b25972b0b58f93aa9279678d29cc07f5f0bbf33044981ba1903ac3b6f465909ef14dde82349fcb173b54162f1cac3c9aa7808366c30c132a81d03659df1dfca6100ea49e67e7183626eec126c2a71e501ca1733927720ef7931", + "1115aa73e2e926c49441d79003bca16ca3979027d4c9d0add9fd8334bb294db173a1d769b75de1f4021b9a481691e78a61d338563bcd5f97ba68ed19961169d0c7b42fdfbad21e5f7208f01fd613285c82889dd466257036bb90c02397f7cc2956394d8a0baa6d3f3d4eec9afd532abf9cbfa33021aaa8d2438ec53a264271fc6f7f1e168067d94a4da4054d0147863db0ff60a60998e107567408b46d90825cb1fcab00732fef34d95e004af03e0f227ee6234c5bfc68a31a048949bcae276effe01b62c60b2e1d8985f652255b19fb3ca38f1fed3cb3ce513ec5c537fdb364752de2fc56f49bf8a4b7a71769e049ee911770954f207dedba1253b1a9db3b93", + "bbead3d32131bbba9f45f81904e3c641ede584b1396b3ef93f404c8b257ee8ba295f9d04f33d1e86f47c6c341256abba2fa72e2829e70153272fd699a8e6b09cd427d01e714b3b46f3bdb30ff7e4e8c5ae9be8ff708aec358306f93623cedf9f9fc287fcfdebd4be3d3da56b2e35ddaf77dfe2800db23ef116da549f2bdf3af42b4dbf78912ff24afd47e463b83facc6f5da2dec1f11438549eed00aec52dd2e1aff7cd5a73e889cdec96dc304e9a650ad314c1d69ad3612873b511cd31a5da48bfb0c85fe06d346d1f80de5e39fa01fd9b03d4fcc91a44baa861d89b5907a4fad317ed053a8d1ab488a13020cc7329b8ce096b46df5986f2f944c672d986ea", + "135be0fa2b9e3244194b4476148f78787d75640758c41463f1b7a1e489de3f2e64dd7f64a8072d2ccfe1a177550d4cbe74851aa65e7105a50032cc901efc55a9045631fa2ed41265b2d98806737bf7623133b3fbab32d1d1ac8caf51ffb4f94f9524cc4bcb10b404d10190e13ea6a19cfa9ec8c32750bea93953914738c463ab570f96dc4c203b09503b42819e7755a6916f1c2ce0d0c3a9ee53e80107d9c1f745f9755f48bb0379696f1c45585946f6cea538ccde11438cdbe4fcbf66f29145d31d65a2a3418a2212250c783712e785cae1f10ff728f0d43a48bfea816531914ba8d8a4c5af9a73ed3a5ca7d9669eac4722cdf64d8678581cd09da4df5e5291", + "323b421fcbfdd03d722471f680bac435ded240fcf7e10d99b685f402d2bfac8607ed7e6d26c25552d1e7b21b3efd3b373f01d71e954916f080513b8310e5c1630347f2435e8df68a0b1a972d583e16c2b28c0ce406f07a0465c1d19f4025ab0ff858b6a1fc34866fed9f4fdec28cfeb8b83a7c5e8ee3adf89e1c28cd836484010c6348955d8120eda20bb08d8f5ca97f9080d557d089bc662a7453b2b091ca3cefb4f673696a04074066e4a8a3905b5cd721830db9841d17b109379dd5455348cd7a17c04a5a587423b72514ad71c7a9942f3fe2245725fe4f5f34555fc0c340c01caf5f1c8d6246ddb2c2e0c71c3d524e8fad2a39209805afa634663796491", + "21b160843430113c7bd9b0a355685dd203edbef80be23d6dcf28e7077c8d0cca975040961da319b00dac9320c225af3a1fbbcc73a84a600e07ed8f116e2f5f12e4fd896341d49127c0dc53b5413ec7afb758d0484efe8111025c2c52811ea5c89d69c3966925e962aa6cc0fc2d204833f2fa546b435d049e79fa78583e7141b7fc9752f31ba44ae800a2e435bfc1d71970edee98e3aed53d9443498ecdddd0d5131efb7b85ccd02eb52e1535b91d3e8523114f21ea62bedc46dd1c57a22821076be7370a82760abe18f6c58318a8e8c696012099900991ade3000901c19484f6e60c8b3e91be0ac5767183ee5b258773d99a4899c229f0f008fd550a3ec86bbc", + "2d216cf51c083493a1bc7dd3244ece6a1698fb621039b4d4d20e6dcd9869e8aad1811e104107f9884e6b7dad963adb6499ecbe2da450f069d39d4cf0af116aba23abc500f555838fcec9b02ce5c79ab7ccaefae51fb6f030d92c5376ae17d68f36b689b1366d9e4c618895b30d5f724d31ee3e3867ef493f598344040cc6088be05675f3c8a3ef6d0888761f5a84d4b7e76458f68db66639eb55d8d8e87ca02aa506219931899470e9aa1acb080393861d5706382128b68a5444d652bd5e8a95a7ee6603e0d2d213f491a7a14d0c21f6e6871701d1b4f5a887ed84ffca5f1db0ac28e42bf6a23f483e1da8c7806c2b2128cab997cc68025f57571d19aa4c60da", + "2193779eb6010f5e2d4d758be2dfbf9b4b26b6596b7bb6d39d6b22c428b161f60e2082e24d0b584a8c37df45f59be039b1a979d340f67653775aa1600947bc1da04b75129c448d669091ae81316d656198158cefc2082ea55903f9f81adc1c5fecd5d737f3bacb4c4a2f3c44642820974dd44daa8b594cf2ff55bd9595a0df1759f2d58dd9ed56600f4899b371920e8def6f511d29384e0b852d50774dbe8aca42a28e05c667e20bf1a2e5d4901819ba1e2f8c685b8125906f45f5a78ed4f5d60d21d5bd88e576dcb9c14580bbd2209374f094fc3ee85454fc6b21a27a2a4947e5804f89e23c1427162d8af36da0f73066e902146c750cfc0cdd3b4d00b58771", + "1be42db43fd51d08a1922e12e957f66d510d21b1d32f79b56bf19dcc9a0f7722ce302538a2e066c6ea72890eb58249c3064e7e27b3a1f80703dcd0ab18afce92f87c83a21cfda8e5289819b5f05888bb64063a88b1e868d0a57f75d38d37af4cc25610d856d3a3ba5b46a382a4cd63897a07011fe8f21087328f8ecab0f2d9f4303190561da5a3585b0bb874523926b399f22c86f7dfbf0fa045c8b8e0008989016226ef8b66eb44d96e22db0650c8969ed8b159c4e7ab1c85bbaaa9a255e5bf1ddad1a8bb2496816ee2dca68aa8b9ab3c8a4245241defd0c88e28cda1d573f4c11a392c588d1b89f68b0136819053e593364b6ff330145bd2ef28a9849a41db", + "14deb946dccc39456e5efad979364f5473d8b8228b943aabebb9ff5d6fe9d54196ba4ec466f0d6131a4326a22db565eaf1b3379571d1a272ee1d157e43f435b8551441a565991b8e8bbd637503bd74203b56a2d332fce42f5d9c4ecc790514bae61a922895da435ca4acfa83a04eda43aa53e2b9746c1b63b0139cd2aee7c88f82870c606726c2c74d441c460d5a666782fe8330b88b1d96b5b9dd83fedbad517f3f8c2307b75ebb6052d814d17c44f0acfbe9219951e6416a8017d453aefb0b94bc34d0afe51a4d585c7a0ee951370b69c485446895dff0fad05abc4a8ac2a76c31050969d1467730041a614f5e33373ab7ba5ec1d6d9001e06628ddf9d1f7e", + "1c78aec377e844c06636c9b6059ed8589720e2797ae53c1882027b59d575be8cdb7b77245e987f15cfcd81ade7efe51d13938e70a1c651175d5507df15651fcd003a8f4ec99bd8caace1207cee168a15390bb289d607059a2745051ceeaf793c3ee16ea171e7624489d89e0a36c7cf0f66094457868c3ffada9d7488c6168508419a6f58a741b61891b15785a1fb2bbeab37682a80ea0155a5728cc9cd77e9b2b930b94129a36db475aa066d30c609faf1483e10017076755c164f521f2b23c5b46f905742db264dae4ac2342229976071c57e7efd40cae78bf55d295e525688c2dfc05e6a328feb27ed8582199dc744f2312333aa93af3ea220e8bb33d3e121", + "16fd4891f410aee4d27b4299303239446eca79f86c980b40028ddf45b22bdfa74c218165069f2dee45047da138d2addebd9f45ef8ce004b18f356eb90b0e94ddcb9aca4fd5093c43eed8d6b2d08ddabde5b9798d1a0a49f67442e4b066446e4cdf1d4af281995ca54ea28cd07f0901790864c097f6f17fcecad0269057506d0fb5ca8e38c0746803b79396f8e80cef73916a23739429d7d6a05d39343937927a48dd9987f8cb1efda7e547a8b78e3e734f41ffbccea6bd962cd460fd8ac37cd1070916a486d81b46ca68021b70ad9a60717aae635d39c96f13f120d9c5947b08792ee69d2a23b597e019b92f7e356695c3a95c843daae0e2d268dc627f3cf10b", + "105993f881ea1c82d5f5da24120426b3788effac63b330094fab892bf4a9f4315f14ca2f72555c25069b3ec59614cd3d6b5fa62fca849626696c4253f7f2f3d3999a0d8cf56019f0d6b16d724ea711e11113c7d38cf1fb32aaedd3a6eeae27662041ecd71f3afebd791bee7c2fad5fb982f78a4fa6e4c95bc01e7c5df304360344d1aaa3c2b16e88970a7ecc31bc0208519c8cb6349ceaa3bd1fcd929b97142c81c1e7a22ee9eb6aaa186e8657c72d440a1444ce12e1ca51cbb8b8d7b11afe75dbc3960c7e41256044fd2590d4798b3b371dc55241ed56f207930ddc114b61ae021eda50aaedf68a6447a6a1309c6ce3c19c83ee1e2588b2dfd22e39b9ae9b54", + "e76093f40030a000e81e7fb919d76d9c165e5a55286e5afc50cd8d79d30933d594c682a52e73fe45181456fe75610071169e955c6468dfbe5ea276e1338e50576202b33525bc90b261a794b1a28ded9e619cbbeeda1905a264d52128052fa0a759fbb289377ae81b72d207310e3cbe67cad948f4c523076b7b35e85ec9ff57ea2b803f4ee7d1d2b32bc24139ed85c5169225be61d973c071d6ed97264e7ae363038bfc86ba1be371a39ee1ac7718ad84e9f124f943a4e47c6ac2b901a5ff3e7f52d5fb2363121397822187a79be96838e6b249a86e386240a4c6a6ef18e4d6395053202bdf5d42c87ab45b4e89b6cb425a43a6d1075fedc2c54043ad2684e6e", + "10a1a10ffc3b7eef1f9ad6ba5a95b9d2767791b6eef44f1a539f3db8c26b824ca2d94bec3dae2ef829237e3a6876b9986b94c741e4a45648a7895209a7a04e7a28ea1efefdf9788c94963064fe60f5b07cdecbb27f545772c397cf0646d1a3b5a53b799540c2df62536a6b57282f9f271baf6bbc4f21e1321a938b34f1ecb62ae87b3272c478c58c2ad8274b8c96cb7e157ce9f7fb96e0029d781253f0afd24c4075fdb73fe020f7ad88ad9e789f683120b8e26285128624762e5e1b6d299fa39e74785c451a5bf6af8c254bcf37a00bf694babbf7158eef739f983439e0569624bbdf5f76d33c0e962664da78a196ae56622b51ff9d8d53d316ad6d49bd3f38", + "35d5ea998ccf6017a5d38d3073301d58696f30559424b49a4e0b677a76303218611c1b1dfb8787979ce56b682ea07b56aeab1b2bda4c1c929b4f8746ebd8dd1bf0f94aff2e3529ced6f48f3731c2a5e214b5b9c0d850f877ed489b480724330147ae7d44e8523a731642cd7bad69922210c6ceea5bb54b798a086ece56d248bd8d50ab2be244708efd26d382dde6291e392b0391eda288b892a3a3d129060276954107d64420aef88d1e2d419997e7fcce72ff8b04bb508db5e0439056d231248c7cd6109e73136fe0355b8e25cf5ed629db23d29e7b1b84eafa0aff1dc865a003085ad1829df7857284498a96ce95a3314a08b799d1418eb8fc1c093eaf67a4", + "35851a618d5b44b7792ad8d8fa07fcf3d161c6f26fcd9d54e002fe51de2990e5edab8f8ba5594c78d6b65501a6ebb8e3ab3b7918a2c46ec45c391049b225e39eade4502a57bda373e4d416fb1b729178120ca14e38254ca4a44099117eedcda770fd0e3aaafb8b4f327d75d97e45fde39256833596c43f6895e4240c7177701ae905ae2ed842e81d37c730e9b5e9cd29abc9663c3163da96b9918cc0fe077514be30d2dd873266eb74704f42aceeed500c2b398698243c5c3d7afe6e197d9709cff5878aaf9fffd5b9cb3f0ca8b02c442ed8d3a62d661b796953404aac7513a1f2eb08ba20a10940152c6ac144dd1fa95c994115df733b01e8723dfb8f14c23", + "db281bdcf07e873a9f80d223ce57133738310fe37e39cdd9b18782a4e2532846e797131115bea347ac0684fb84ee7a32235582c8d5440e84996373bfb52d16952aa50a3ac93f627f2d42aa54c6e3a7e1b6705ede043b7a15f28f0e226427fd627cb3b88c5ae7a4d22f9d3e72f4129fc0732be04cf9b504cf6d24bcc255e552725dca2ed9c2c84e092adf19313733e848d98b9f6c2f4ddac35d6c54af904c85efb77818da0f08542371faa232612b16f697061b2ace9702e679a9e6ad2ab1422593e1f29bcac0f6e46dd702bb03b4b99ad3e2d84fbb70ae0143f3ef8f4408522c8284272b3c1a8c45ce042e0797a7ae7f950f3e91159e202c691713eaa2729a5", + "2473c5d8787284c43db37262e5fb953573b10d9e6c0849a1e5240a4772da2a2201041d42d8e91b73638d91ceb0e5fd9c4ed32f884f374059885a2c45c637aa41720ec43260e08828925848fdd30aed2b4bee6567778ba8d3a085410f420f1cc5c33a084f0fe2206129141319ddd6cfcea086c8ff5cd39af3d7b77d89a3b1d17c810f50a5a95b105da4c48c6474a1673b08c10ec0677a3fec95f2d6a7a3b584dc002daf11b9e862511257d758015032ac14188b88a05fa8b5f6fd5cd263495bf6503f0e91d91c558fef3692ff0d96c1cbeaaaf3462d484b7853a9e4b834887c3798243452e11d053759fbb28531729fdd5f290f5a3fc676938b63f98c02887ae", + "30bba4b66d97ca233e1110cec50c990b3714d7f0167c6b61a8a0591721a27ecdaa1fea710194f0738823950650bbe2ad28d70ac41e0ed6863606e26f73bf97092b6348aab78a04275fc685bacde91605bfac23f727e61eca59c63ff208b7d25426b1fee2463baea63f172b8e25b5fba92e4e7670768177660dc1be4d8498e0bb2899d7daadd17a133956980b24b39e574076ed70a287ba47bb3c1df7243a7819f7932a459d208e86eaad3c4b883566a8efd510f1b9a96773a3308a4709f8e9d2905f01af7463a1b204ce026ee528e547f967afc7e33e25b3ed91658fc28253275deaf0842fc9d888c249253140c6efaa3d5b05331d2c8120a4f39b1bd6b70d89", + "16b0fef98f884032d88b8a206f7b0bab917fc5692be38de21a648bc092c905f43ac5ccba2f7237bf0cba8b85ed5031eb47a1f8dc170bc8117f847bcb597317718679ca3f243b4c58fdaded90e8dacdc4f91fe1086117d82eb1c5353bdc613fc8fefda69f5882a7a790082292c8e8532a3cdf5b57c958cee6f6d479d1ff1493b4de96af8e44b19c9a5240dddb9d0f10fc6abef19e48f47dbe5150462493a4f39ba842b7901a96e3386ef950af1b14c049a34d3218e95e610b72026bf50ed3a7d44c46b82374584f88a3ee8306b4a0f27cfa1f5e6e8b2a8b206807e26357011be55576c8849029b2bc2002934341484d73cd8de1cffb5e980ac78a1f0c06212d2e", + "13f3eca0c6e2cd140c143e557aa9ef715c6736aaa67211f22a76ff85f2d2d640aa74884569aa93a6e8d065a2e222881c8b3a74dd57bfda5e7dce0997c5b6895feec496a9084e20d373f35f8c24c9e5628ffcaf0fbfea3eb33580e963dc19977834a322289c25f93f4adf64283b28a3b959ff22f128a0ea27b99c9dc9efb5cbbfd7737973f7daed0ee08892b81581f2fc61abb26a72a5490de81f2f49349058bb2e59e0c2d8dadaaf41060888d67ecb4c292711476a861fa113bb4c8381285ee0b73a91505ece3262562e2925a03b731888548cecbdb6af6d876280753946ef19ba1e1911486549e8bea45ecf13e30eaf68540ac35de352102998c2fde4d6fe95", + "2db3f1c96133d2445d6023edbd2ebe90f2d30b377419a339c7a485891b00f94982b39fc167767517e713d5a0e8101688e00eac6dc32a879ca01d4fbfb0e202a7f2759524a5d5fd6d58d2e7759d82c96711c49497431e90ca1ccbb15e9d9ea8a311abfe32f27dd4f2bc775071bb8114fc3c724e03f3883229e4e1fb204ec9a29f73856dd7a0e7cf6139a01f2bfe9b6fd97379378972572819d35bfa995c4eb2142b6079b6245d94c797c53f32854c5809232815bba1212e630facc6f5a57d05fdd970cbffe62b12051d8189070c7e85d77d3006c2467d15145f701acdcfcac4a34cdec92be4e96b131d5a6d7b515a16a8d25e0e165599a2d1adfafec569dc88c7", + "30b33c5eac84488399eb5743bebe0913babcbf7b77922e5cf2adecdd8a5bd32b457dcfc40249fca04485f3336e605080d0241b34a3efa7e18bfab5726eeb1d95d67dfbf07daacb63d11f91f6e085d5686bc6f82a993c07629746bfb6f8be22c2897111a2f296a6ceed02de6ff8264ca7c155b426d020a9e9162071b5e2b7f6211c702f3b16dd3c176d8e6abbb6b7aac8d51b528929f94c52574b0d8b798cc014e1e71b84476fc6d8bf20bb163cc549e58ceacd40eb23805782931f942a5d5ad0943372d96cef0ac9edf8834c9f4f0e36f40bc281343f48e0c91173b529d09a5b6276164cbb3a284896b9161a084dba21046494946bf55c4287dcbe042b67cbb5", + "3bef38645bc84a5122aa18081fbc27f28d00ddf068be036647ff4519d1681dfa9e602475eee3175cbe3ae50b308fa56cc979f77f3f21d758f1baac3686884b11b026c2f78cfc3da723283baba900a7877bdde55221191ade4d97fc76e94f136d989ecc4609cc134221bfc86dd99c207a374886f99952ef20de895af2432a395e3c26e789a5fc8ee91079290fdaf8bb6f35d97bd83f6830cee715eee8a81fd588e167ae9190a15747521aa9973a9235d090e88e893d76b2d90a090197c7a0413627d0b7aa56b1722867e2ec0e1cba6a4bb586cdbf8ef3c453ddcf4a41b5564095b190a2276803b14e1f43b73588d606c3f6228d163dd75020743dee9642172e7", + "c6a5d8948d36a99d9e8209b26880e839a01fe884540663db0f9c354f017e8dafd99d01cc129cdc4ebca5d1218836ae932d2772ea732fa574455fdda83e50ca1e0ff6e378a9e24d0e0331671a2b2cd89196463361ab4a5266a471d317cef673abef622d492674612d03fd18480b492d9f884043705c9e4148632c3e9e2e15689f08491338f14265d0c0ac5b305786d28a8fe5dc26b7c0b6b416b2f5b505e7f439e05ff62ab7a15400811a0f57a147bc6b16e1e5bb950eb6b17ad55c946e15a507d42ac192a68510cea6ed743c795f404535d61b13507d82465e991efb68112a5af47f849fe43313c8f80f86edb84ff115c9260ba685bb865bdc72b76ab2cab0", + "18ad35df0cd0c57bb64113e2a7e89b732cb68ca575d6bb0f0c8575a1288039ab350450b3dbb504205b0db9bbc129bb6aaaa344f3b89e3c0fe349651157f6845a566bcd586f8050ea7c6c1878c46cd71bbf5c2119abab7fb192269d9d83e39c2f138ed00cc9e1ad5c5d7203949d00f34a12a846c6994bc8f90c99e9b6fd5d1c99e8d3f17cc84db3ea190fc9735b6fb463eb9f0d4c68c5edba86300ffd98829de4d95fd5ea95253599751e17314c794ee3784ab05d78836ea47d1c65a806212e78028a35a4a5b659072043aa15d7237db20969e047735f3d50f7a02c44e507c414ce2bab4f0681fe1d2cc638c686eb54cd82e2bbfd153ac7c6a55074074fe18326", + "ebf789892f5aaa1df063d30337dc429d443585189709afdc433d6d12eeb43580104c425c8ba9d815d8a8dbb2f25b2627550fe6a53687adaa81b6e85558b21d445df6ac69fe2100e477f3d353f3d045bc9a8c888ebd03061ddc092acbd443c4828f89874e0f5b7ca098c68c440441eda15b3c13ad6b27c2b6991222b86650cd9ece912d0afb68e9c5bbdd1e6b9315d1d0513a4efd64bab30cc0e2ad6e9d6c5a1badccaad28e7447671b7048b5e41f0cdfcf28c9e04e538955ebfad8f53138221392c7775ed1a3de5c4b448163519b668fd7dbfcc77012aa5a7449d0b55e33a040903caeb3d2ae5e5fb6d966f6ff8f8d1c7de2b7261a33e8a93875946a9620b25", + "2e1f28beaf60bc262dc16ebe28f7508c69ce12e8f06dce56f018602fc8c615349e6b086fee3202d60d5e155d4517a48f9c2e0d154b77de84dec7683a224087102e75f0d60e58c3585baea9abe1dc8f59b2bf3bcf28f84070ce315e97df98c63f2fe1f51f987d3c4974ad783c04174e2f94d6530d5bafaf9bd6abcac79befc8f5ad3872048ae2338a353c4ea79e1abce586a757f1bc147059925959e9129a621d4ccbbf3c7b01a4ad8e26981cab409fa0637fc77b39773449aca37bc665b7ea973ce786879c1fb5617cc5ad743c95f3b9b2b1b1a8f56c12a5ed569e7a78a912e315213d03bc9ef4c606d4a9d303d22e734ef6b9ba840168a0c6527fab746c4a83", + "26ff311a6486a1b313824c3da76cc1cf39bacc110a90b3372716f77d444ee48f067ab3b58cbb38f9b7cc0d338d48c7091d95ade78470d12ef1cdc615437f52354b585797e6c868023d27af32090cd8e035223376c2e90adb005ef32c19de20219a29ab09d299bfd2d91988f9db3ad2e124cfcf9c8595b24640088a07d632517762ca58c403d05c0431bea690353bc1472aa6cc8a36c72e272d2219078d39479e93e5fe7a9560dff4410d753c72f1d1cf51f4ae1bedc3d6c4a9e467ee3305ea5e12607eb54fd264403590dcd6427d82dabb24c7bb233aab99af900e44e1311f28c4010a00b1283e4f50df480a06538f753527803a2b0a5cde50d70ae509502fd5", + "6906978f0ae23ef873844d4e2525864c0e7d17f64cdca07cd9ffd6e4ce359997a6beaa92614cc9440111ba605723b80a08d09ce46850cb8072ba84b6c0a444240c3eed097037f51b10249e20cbf36c847e411e538d8f808b7bba7c00e5e059be8cd5bb07635d05ea4648441565e9fdf79aedc744aabf663156bcdcd4131a779331cf46680ab0017a33d285ee841966731001b3743857204ff6a4299dfdb25ff34e03105ad35f3898839681517928425efdabe19ee8a9c49bb35cb9dfca01bb67c983eaee399f04d64b7f69da8cde42eb0af983aa37d98e03d0daec6d1df169f101e9f8eaa1b5d6880f14d32f8fbb6418d21328cfa6d07e6e492bc15b28bf27", + "21ea3765c576c2ad9b30e66cbac2cc1d2fc237225efa93a56c4ec4b76b35aeb39bb67a61325020197cfa7b53dd62b0dbb157991600f64da241ae023306d8a3be2f90e7f9ff682a3056da6af1b62bd6ab410597166763ccfe561912d317e2e4a458f1659fac56f6174feac2d3d148db258445481e5265e369f0ef83095c115b58ba83ab89cae4c69ba95f3bfd427fcb26554bf6f06fbc443d5f44aafab71dc72c05707e4363b6cb511656953d751c9b49d37f4836acb788e0273f470bccca7d752bd35de146abfb4304ef280432d455c879cca4a32a21861904e567f335c4c8c01c8dbedd14435d52c82dbb19a51801931f5b81bd31fc48c96b6d0436f41a38c8", + "6c5258e8804f826ef3abadd6d4e81348b6b008e189c368bdb3c40d3348ab0064b11e917ada9fe81b3b95557966e1d1dd3f45e5cc8e63fc897c260b4a7f4cb2f85fef787222f259b61b4545969f54539dc279842960d3cc25cdbba8954bc98db8830db3974ac06678f73dd6210635091f8cdcf305abc6bbd7d24643c3500e786e1f03f4b7481d8714b73486ee62466f8acb6b4ea1aabc8aa8a5c72d563384db488e4875f2a0902d146a46dbb0d5d11fb1ebd72f187fd4e0239a3ea13737f15af7ac8354cbe2b09e657cdb10488d43457183ee1a646fddcad41869315d4b939e89dee089ba18c6c378e334350806ee236ce18c3d1bc3d71554f70581c066e9c13", + "f3402d168976f2caefb379823e14a5fcd4de4f7b78402cf77cf9fdcaf18cf3a8e4c9a1863c357a5b45252c019dbe875ad2edeb38b80149c6c2dfe34900de244b3e7e2e8c4cdf9ec4e6af4dc45449c019f69dc52669c8110d28b06b48a7ec333cae9d49c77dce42d65ad55b23b87f5f62bf37e7b351c8ca64e1e7c6177efe746f90489b568af0849afe77b705149d6a4a5f1b180405002342f52e71cf7daceb8d37312669bb22f1c3c799a27e7a983a525665683381994d781a945120075f1656d6b34a9f9718a78c135ded788d3ce7b0c8fc4c2d6a1c268c9c31b10e3dcba61eb8c987bc9ad55e03ba40b4d3e22a2c8ad7b77dfeb966d6efc296f09f0f18a1b", + "2ac3d4064ea02279ead2e8756909db36ba02d8d0fac4863b60fac357e3271fda2c435d583376fa6f7e31f891b60afed8d82e63c991198df41af79a8a82a7340253aab836b2702da19e6f4ca81fb1af861fb543857357bb100d6fbc874709e99e1b0f1e724b9fa49bea3fa112334b32fdfdf3b9c678ad727968c6eaa759022dc39dd535ce6a8f0169a7ef58f8b135e44bd8388eb9a8c491805732dcf3a0bf8a1fc16fc4691bf5c8bb6b9130a97d31d2deded25f46f8d762fa4f9b9d69abf9f1506fd8265f581f6862d160fdefa81a4bc87387cb08c9c92e84660d0ddd2c8217315bde7cb48b2d1a2a9c2fe1be2e0808789abbf3cf1aa349d81a70a659b75cb556", + "33745fdf076dcbd53113d0e12fa1fbc2a32e98e272e53d53f4d0ab8bae055711bd7e5e9129fb837fac59ab1310f3d639d55df0baf576a37eb44ab61ed34d1ba61e210bdef1a1e194b388ac8d8b3024f3521b580766aa266ab3302289d8173db40ebfe0165c00d4cddb272a98fa51898ef6c60c783e060624c24a5c6de630c22e5fa4b982bccee09725ce872def216c4f36d107f3292c12d942d5969323286121334dbf5280f7d3e6d79fa24cc7009358a362962d29cf12dd33401d4029886a1d708fc46364ba9be4d99797dfe9bbb55680dc6e70b30dafc383af2a6f1539467c4eabc967a4a67613fb7c8394291f14838a63e27c82ff7d3f25df830dd723704e", + "3192cc313f32a484bb6d73e10e9f91c78924b221d9110cf21db07c159eda5f011f3c0cc899780b76a09378f41ae160b0e8be199511d18128a01cb857352a7eb1707ba6ae6156458f09c7678d4b52884b5119d34fe880b60919be8818b689a3c0eb64041d7110ee26013ee9c1e71bdcda227bf14f3232f52a186bea2ffac97bf37a075805ea74c863839cba019d8fb9d521342716fc5c87617de6f2e03d0fe3343692bcf75c51dadefc8e70d2613299dd8782ab73b90f50cc2b9c5d2a259825cc3d1de130b7b4df9549005b2e2a67ad9b38b878d3f6c810d5a8547b766c806d8375b0e81c16f0921da0d342bf38bee1abb04b1a8c7b49a3725a59472c8cbc555d", + "2c947956070f315c09309dfc07d79dc933ca2d6d485019df2998bdc51aecb9aa6d7f1238c0c72b0304d6d805cfec57f1341e75208635ce6c78ad03d5272b2a211c713f26b481ad472d39c852d8a7dcd47141926e44a7c7aeef042b80753a7fd4e33eb2f4b719f0af3e1dc93591b88193733576e8541f0580e47e3cb78fa6532c2299c1dc64348d82332bde221307731b69cbeb05fe4247bed335207667fe8e74ff86135b3d476be7607c992412a632097f2686fdba829190166805eb5a9515838e380945956cacaaf712c2e378496a65cc8c7c535726ce8604cd0586970858c1ee8a65214ba13d34866173e594d344638e417323420b6ae8ab6f8d588967d485", + "f9aa464f6d841f08f7a47dd73955108006491301cd751482cd2ca0720083743624291e07ef83dd6356a34ae9b23ccc36eb6d4343f36efb6c5581ba528a4b6d6ddefc00f2dd6115329b312909a77aa2397fc3bedc2a289c2582876f46a832568864a149bf48658b1a9446a5f6fa74684f03cbdc44f8c920a17da42620fc6a80dd7b2a690988952ad5079cd055052d5cce8caf29366a8789ce61b9b1496f1a7065b1dcda5f21917a9c45098adebc4d86ad055b063fe4d3b7f1b8ad7935d0ac7d7f630fa64353b1090ee161d3fa4e76e774fb3aa886e12d84b316f1e0dfdabc008653ccac34cf96c1f400e1206e588bfc5ac241454b5273eff02e165e037e8637d", + "1cbae0e8113b4ec7d350b61be4beabce0c6e80339b7ac0d8a8e45f31f5805d25221e21d085b7d6239068b526b30cc2a485b76f596e6660577166773377cef238fffeae935095e9bc5f1e685f144d6c3c703007bfdfe5e0450ab5ecfdeff9c397277b7a2b3a3c1c132d7832196c1a5fe65be32e7a09833178730ca2b9a1eaff91158c74216c8ad35bd95a2cfe9e37fab37dd1920c9d457b276c8eef9137c4014e75d942ced15bc823f24791b30c192bafebf6d529eee05d70f241d8a495af5847a0a2f0527e0b36f11ad72c28229a80f30851920c8ac341b1bf059b4a49f05cd77f980b7074d2464b1a6984765046d925f43b99de17bd861e270c63bd9bb9f44c", + "23c4f47c61109a4bd0b28166344c86e049ba4b5fb665c2d6e650465781905c435a706f6e7e5be47457c6a0096ed34ded2191764e03b200ff407d85ccaccc9a75e8427cd9fd88c16993567173658c4a5074a0c0a0176d0273aad382872128dd758d85e56c512aacd3fdd30dd83af828db2cd8e2f545fbb5b5991ee23e45301d33cfb7a304239fe89f21c8313ecf690e3ad6da3918be5f07fb36883fe086a8aca1fedc9a178a9a5b26ecf86120fbe1098419b1604ba20535e4afecff31cb566bd92b05fdc5bdd8e94c08677a589220052c47212e0dbaaadaa47bea6ca38ca0f20f89575526b2544c02f831d13252707ed4847c2eb5f04ee0222cfc5b000ffcb9db", + "28b2f48b1586cdd9648f2e2b1c2600da262123bb72bb61ebd8f4c13afdefefd1be5d8194c9d868dcca2b1612e0c1f5eb3ae97385e6bad791f691c5fe5b0a52eacb7b93fc7ff953471af094295e388715348f833bf8c2a573e92694f7cdf173dacba79dcc6b502f56ccdd56b81ac1bbaf9c8fdb1718dc2d84be5237b1a3c08f3379012340f4eb8445124b01024505911003e7f5a8a5ac3b18975562dac8d1b86e0aa988473683e45a2c54716c78a0fa03681b53ac5c31fe265f8fea4344358814e2766bc193bec854dc8a20da2537b86c735ef30edc0390885a7d479a9e389ecb0c59f1ec14d42f89b77f1f9b7bb7f11f73d56ec94c010854cdf6033877d786b4", + "1d8569f6570b804b6d209c0c0b77f634ea36470b0c281ede4e9565cbe38d20d5126ffc1432b2ad6a20dc0aef876626e9a50a97d44ba10ef5b936a203e4a083dc08ddf53916c72239d3fe1fe44de36a8b1c2e6ef5fbe5c091ca5788b597893f0feeee48d7e3668e6a5b23cd6c9e2396fc03f09b3987d9b4b38a54465f1e366beca8aed3cf196d928604ac488067565b2dfdf063e46f1bcec0e161d6b7975c182c875ef36aae9c86cd3db6a38dd18b96fd68d9139aa66a8a771a4c5545492d0d9d15b48b7a8d2ef6fb1c3fea5c26504170ad62409d947194510bde939848dc09c977da5c6f05a29a2c9e1aa154ee97e7a24a692602cbfe7bac4f9094784f5f35fb", + "2ee82de6693c2fa199b8ce1a4609b0278c7a8c396f88bb6c3584e462e28e6f8c19623d02a5dfc6f0a0959457710beca8c118dd331f94a7969af0b926d76712bc211e97a1ea08435a3a5b8533cff2d72c6ccf70ef39b6172c14c3da1f5903fdc83328c74847719e200b6471051dea4078799df7cbb9015653ca6411716eb330e378482aac034cfc20bd7068b4533992e8d03eff9aa1c0419b618b6ab9bf5c82e5d6d9e4a669de2bfdd58200b6cd337bfbe560cd6f287448a2d4b2d164b40c41120ae25c9686cbd609d9cf7f31f7db2dd5f081db6f17d31703308de494a37bafb5637ce6bf14360cf473eed5b820021514928b0134e736403cbd1b7c2c00379599", + "b183fd29037ad84b4b4558b2d25eb59492554dc317fcce5999d6669d77ceffa681adfced65bf18f1b3af0e000f77bfdd3fbf15312731d4c739d3320eecb3b39ace66cb020b2c12e8a55078328294bd57be8678168f72f0ac0f37a3caac99865016665abe402198d9111465a1c496995d5dcd0c5cd14c6f4b04c0954343164bde198962b603af5da22184a62021a0a93d4eef4e88ebf9d93dfe365c3e630ce6e727755fc32c4dfc3b97fb3bea7237749f6f742ac93d99ac32c332e5043316afcc30d1f127fc466cb826a66278a4b80d7bdcba2d91270d8e3862e881b38832e30f1dd0934489d6d478c0077226bf01a2a1a33920b5527e116a8a14002f0b305cf", + "2e36daec1fab897d9ecfd5785edbbf5ef2bd2e76c08e5675f15710f927f37096ad97518543da443f6c89302584b4b833a03c9950e55ec360732b621fb1ea73ab8ed2576b164c4eeec646dae83ed801f853a5662403c7304c45f7c76b03cfb3c01380fb7cf16c7de1383ff9685c07e518bb3ac4311af9219b85b30006a8f507d7decfabc42d013dc6dc4a3b42502e5e523db4266f176941ced1f811e88e240c4d0aac9dc826aeca18e241e8bcb0d7c52359cddd3e66c104f9403af941688bf9f288ff4d9fdd509a0508c3fb2ca426bd97bbcc32cc7039da6c37deb0b7fed599d11f684fa435cc38096257473fb756bbfc64a2773a4db1b8cea0b6f5da2c278c9", + "978597c955e424c822df919597371f93add839a62746105958b202c8a2746717ca9f452d8c04263d91798697688e041751a093e18346ee12ee0626d85341f55e42f6857ce748d628a9c1a06f8adc9d31edcbc2679c010f2e6d008761dffb88756671f9ac1f2a3076929a9a54c2847c8dc256f95c979b6c67eec84461f8409b24b7c201f2f816fb383a60806e294b2e0b4e5ff4704ffbd36d2b91690fab893267476e45f7e7cb8ba4afd73be3f84b88b8c75b8be91ee412b077ed95047c8a3534068b6abca18ff8f6ec2c1ebf4965af8319d7c4169e646e4d7ebfe58638e49b50baf3c7750519c2dc763fba46f3b990a199d440f7a113a2aa5d7e32a78f20873", + "27d22e3153ff7429bfd03ac3efd426d2220c1892e6b20227f2fd284c87d3451dde27355e92e48869eea019859fa8c89f3221daa51c231ac6e8360d58c3eddf7fb9d3090556f2f1c7f3ceed2d72efaf4182e5d583f834a509e75d2ad9537fa96c65c179011ba52e7a1845af173c1094ab4910af1aa79de33d7a8c643877d5d92ff26c752c43405c0fb3bb29a20af70249d4690aefe0b10f91cb6a0e2d86840edb1a3e4b7c7d22067b7c21e134341778b47384a616dfdeb381bea69d89a7b9626deea25d5987c8ea08afd2ee66f5176296566f29587afa9deb243d24ffd01b16bbddff3d9270cb783d674d8c281cc7e6a53a81327cf5db99349b73a6dfd1fdc20a" + ] + }, + "factor": { + "challenge": "-5da2d23a42203051ad5aa4b7eb8f084513591ecce4698fc9c166f98be64536e9", + "inputs": { + "n": "bd276406344107286ef49a2acde336f5975dc24bfe350d57501071014b374537099933214fee6277bdb4138a1b5127a2f4417c30c9b271dc03e86896522a1b18d25f545932f91ceb5e037712b1d121012c1649a6d07a6acddb225a6804e58ccd9fc88d5c872ed5912c5f4179747b828a3a9740331b0d4e2157ac88b517c8f7e01dc6475d61d60194c31faaa5ae381c2615d7f1c4abe0a3e544811ecf0d1494461066b354a201a78e40e4f289accdfb15445e1248808a31590d7a70659f2c55721ea4a821610bee961924a3af65a0a601d3809d2bb9e223b94c96b2f2ea926af0c2b88b95dd334cd683f3ed3f5c446e918e9b23d219c8a9f58631cc94aecccfc1", + "pk_n": "ab9acc348c6290f126cf3cb35e29b71cef8cf1c98d21f22276d540efb4f2a74a722d2b2ab6fd3e400621de109fa0c82104a6111d476da33c679fd58d32e32551e1f8e4b39fabd9ff7c6e5bf76aa5b7ba72ca79bb72eb68ad72975a6d1cebd0bec34cf56c9cab4d39f6280206b001d6495b6e1c58f3b050be29e078aab5cc45cc201922715dae7f72bc8810380a38c17b7838e6a18b804e2a25d2d22977fa26dc63161130464af47dd5c42dba70a85a0bfa2e3ca4889abb3cdcbecf75165ef6345ef1e58f9929df65ce9bf33a53e8f1ef18c73231c70f21a30c4c21f10693eba687faaf5de5f3b27e020527539b3a8e8358a929bca06c1ff6c3a2720ee19bbcd1", + "s": "f21c50993ff18390db9d37e26621809065359c0ec1a70ec0b90b71dc10a070305519e2dacb54dfee66440cd4219c0bd0e456631c0bd326627c1005f36e02432b03447149a4ce0e62556531fe907bbafd11e1059af12fc1fbfffce9205222e42b02c18622e88eb0dcd22f098a905cecefe4672e7e8abe97044f1b993f5294907a5d595ec23179e82717978d594f205c5c3e904512cd998522b933763b3f0ae56ee684c1743ca21c86b6f98f5200fe352f3c2bc5641d8146077755332834cfa5ff2663af15ca0b7a239be9b661885be6f39455bb4be1c3b54c2d598683c9731ace5f19ea7ed5c1fa85f8e304a50833bd1a66157c92ba2d91f021400d736e39b05", + "t": "23356a7ac492a79b204f34ad22f474c3fc03f1254d2a4d24ecb68a670f1cacd6c2d6e9522edeb8d8e58da89587ca88ba878bd2d72ed3ce74104996a937d7a5b8e68b26200671757e110764c16b2ac2671e03c56345cca8bfe43eb514a8c7e1f45d05eeda3b4814ce63ccba37d47756efc7436dc899c4fb85832a10d05e11bd3210bbd0223c19fce9535c0d3dcbd3cc29797fc16a25e5465c400fd0ab9e93dc4c8b3ddc0e736bb5034bb20ebee475d4a837979fe6dac91f967a90405268ab6293498592c15d8c556ca5e893189f20cb4f93618818e19ea2fd29b44cb3bd3afd7641d23eb22151f25f37f6c318531d2df923ed299444883313bda323a591c695fa" + }, + "proof": [ + "64d2825ba6321ec6ffda63ecce9649832a1ada67a9205fec81c105fe98120a44481b1cf9d843907dbbeacb880e680f140971ee02a0f20a4d85b12f50f394c6c30c9b60f70e378603172b192b5adc9aca63fa604b2a2280ca1d237dc00e367cbfc16ab286b1485c72f3ed444d9b44e7c9296305fb99bf19816b3e6c63d50b4205747d55455f35cd94392a6bbf3e3937569ee99b95dfc38bf3300d3f092a3694630a3a6f6a8041bd2c18a4ce417ebab336fcd0f071f03fc3d1e16850aa76a384e4bcc9cc5a53d5e48f8207228a721c9236523c15bbaaa11c688bc655e313c3a5d992e63f1065b7ca35739dbf17b5ec70fd32aa65b27ed20c4d563c057162364d5e", + "105c6f08e7308293650a162dd8f1e3b15a1db4efddea09614a2f88c61f37fa6eeab6c450a08f6f96f6b829a09d8abe77fc7848b377d4fb7a6869b2b582c670564dfc3c8e8dc5063370727f625ad09b4b6ef9aa72f347a19b8d9f0c4fd50c560b69ced0654f54202acbb6894060b43b72dd85062846f20da9b710e03433bdf841577bfc52ed4b513d22d8b191221efa445bdd8095ef33c775528bd81b10f5c2244753adb3c3e7c436c0cfcc47e2d2bfd6e107f63c3dd649f67ca158866f2b07fadcaec6479b20fcd33d1f45484d41a4b8406a124cc3fa9735ee574d955f69a2f91418b9f17f89d1eeeff1f08372c3a00bc22fb3fa281cf34c343757a26bdffc76", + "68c1c5ad289ccad6d35fbe52f16052c5d8767b31d14bcbfe3e0f807756edc299b3a1371af75ba8f5d22eab9055132fb090efe5542db6bd38aab3154e10ecf69df7566767cd161a6ff8344d8b04f7de2532c3f9df84c336b661b62427866666402c7b3ca54d496b02d3da2c7675798e59867c27e862995fddf441aaa8c0644fe96a823aa9dcc9ebcb3de5462f7bf3d096190322d90968f79cb4d125e4bdbdae118183066106bca27431d90fde753676f96221247b6ccf30ea9eb2748de1dc439c3acfe52552aa4ed3ace719b9b986e7721c26bf9e1c7324c4d4f102ea5b519c97b1fdf9b6b3a88ddfd9a04e2854413315d47fe44629763a3e1ebd76cf2f1867b4", + "2f5740c595dccbd06ad968dba7fdd5579e34dc12da6ca02e02d2da1afb59121d31cc86eae1d687106307d86705b836adc9923c8036ab8031e3cad9267d536b6f17d4fcb7c4b348864db98119d140a8a2138e303b45b1d344f3b1bf5e93581c493475e8a9f441d2dbfda187d625f12ecbf7914e6c33aa9ad8ff3ff9691707bd24e8bcd552eabb1e3564f590ba4c2c6e3288c64a5ac47728ebcc3e9757d734232334f3976d4623569771797ee306f28d9f411ebab2f5bf13ea343c6e4ebfcc8724fddd39e4b086e014fced9e92e6ebb81304642508e7b146c134ff14ae9a2b5385451d0f83cd17c483588af8b90f7d63eb434b71b866fb0beace8ae6841a0f108d", + "b1db2c767a627fb1d0bae8c3a076b89c81f68d3036e7624d9b3702af0adc2921e0a1559db0df5bc248b668ea73788c6480606b044cc1501dedda0d253e8621434cac5533749d9c54666d53ab4abc8f781b6975c804ecbe89d578912e1a68aa6d5de24044f5a9e6f69720b7daa2f64f460a18607bbf05e6f24cd405b5217b9e7e74c0932a413facb56e96921a5506c323551953b6ea9331e352c5a98d5e1cb2c7fed13d9034fe0974e6b239a28e538b3e4b6ad962e927977ec93f291aacaa010ede3bdb8e7a442a274572c8ab10e5559426ea2457783afdd71e9b5f9da35d3dd50b03e2f0e5da19a8d056181151d3209ffdcca9e1783b0a0b7291ea3aadbd3efc", + "3ea5147837ec90e9c8723ed7a048313f374c815b3c11b9594b05bb7f6f2b3d0594945b7d054189011fe1db60836fbc6bddeb0f3e3ef3badbdf4b7ce582816d17b0ae5053044745d6d34dc4f4d83d9b47f454121476ac041b2b23377a0f1a64913cafbd3e151ce9f9b9fe2fa9b2833fbd5ff71aa41c9268ee98339df6ef2d6554e49c224cc7ee3d34cf8d024597b82a2a6ed36583381010f34f42ff1d0bbad94a7f88a13872e7b0a10ab4d980faf2baa40b01ee98797f48b325e075628f010ee6b17f3b4b1d0a68329d361d9576fc7abf53509e0e5789e461b1b15f27bbf65eaf4e9440dfe3e799ccdf4894f75514ccf081a127d6a3db27502feefbe66378f8cb8565547763f583e5eed2a8fda43f571f1a9349e67064b02611c8f267cec0b4804ed33e2ebf41b452ee8ca5e7a01b8553ed9df45876022a880ac550edac2f38a0f79c14558a9d7f75d860f753310fb001791d001bd6e35cc2500745ef1bb90f398052c50e74c9f6437b56f5c65f26c1f2b1ca1ddea5f7cd011757773d7c318f028cda55cc528147b9d300dc018d04d55ccdcd84e84cc85644b4c67e9b83d9edff39518528963ecec5d01e6a4586f4167e362e3880ac3e211e497057a68aebb19a9107c27c368ac16df06614bb36a219b63d2558c2924c6b9b25d0fab87878878211296f9bea58a8a3c768b347ff5c4ae19b35f9d2c714def957e1d67c9efee81bfe33aaa39e1777e19d0222a4a3cbd995fc80e20a41783a2f9f7762e92af3931c", + "-41ecef455a1cbb5fc64527884357e58f6eaf55b3c723f00ea22d4b5a9dd87c8d0edf6b019c63489b7f3e2052b780a3b1c6d35a319533e71189f632bf6cbc86401b30d05c24183ce6cfb0562ffca0f58114eb9b7d4b9bb4e883740b3523aebccf45c1cb5b3e31d0e629ba5ff2881c3bc45819b7cbd57f1c846c4180dbb773d69c22b880c17b594e33379d2912022eea5a339c25d6bd68fb04f4b60af40ff85f063ce3fa29608bf1eb667168fd5827f3c0f1fa86651761973452e2d2b5ff6032517bde6ad3521a88d57dc4f372056435d56cd74f90680c84aa8fb54ad3c119bc6a", + "-67113d0decae485cbe1d25346d448db650f39bf9d309898c7ef1e4debf5b558a02b28a822b5b3f3b4edde857828f3ae75d54c295bf80b24c2ffa8303c97297606faad0e27248b1ab3fd7edd061c53a002b0ab31b7d0b243c45b7d87c217f0398201c32d4bc092db407b5be66fa616dfe6236f92341e165d760afe171b4ca4b108e07a7afd478901631bb4fdbbfbf8885e19071e19b5eb6aa6e7cd85e7bd5b7385afa872ef37413d7b5b16ba511a0c55fb0bf9eab57a03c833093ff584d0098426e8a2927621c57a1d04e9b4be27b91ca35bc39b87e6078b0e28efdd2b6c9f882", + "2c8413bf4edab0d586394ca64c62e04ef30fcfdb9178967a45ddbaa34d92cf8d6e36fd04df73808112efed625e410d0638b686f2da3a6b130a05caf222c6dc483790aa7a6ae33a2b4114aa3644160570ab9fa6d520689bcf5cbb2785e60b1b8d0e58f32154629993e69c52317d86e471f47a29418a3d5762b100818b0b3c536521142b653e5036163ed15047beeb13054d704b5254f1d333fd1c8c8780fa1f13e00d1613e93b75ce0463fe23bbc02a0ab2f572a7a6ed02f87c96a10d2e6ae924ab20d1ded74085bb6fd94eec6c2703847e0e8566436d0c7c3492115fcaf5048fe184f80798d8a3f2f202b5c7bb7be26e7123dfe0fcf0c76ec3742fc49ee3602ae81eb4699d9e5ef7211a5e4aa60d6504b4d5f2709ea20b58660be321d72ac44559affdda687ec26c21a0395334f240a3ca426194235968e96a7d9354d552071222134e616da610cf27c3815aca58f8b228d99902489f2d3fc101430c5a297714", + "b98750b3aa61bd000ff2d1ca7182f18f9728f08b3874683a4cae9715d6cfcc173013ea6e2ba4176224213ac35011359c978d44875b16a50bcb344b5de1787e8fda5e18468a4e8ea00a7686031f09d8ba77be37c09a839c9fcb743c64d5779755d3cab3743d5ef394b41cdcf3dd2202a84dfa6e4366062779fa38c5e5a38de74704de294d3cb1509e13d0716e21acbc38b4245b26a67455853a1f033ad3264e9a9013ef3189942d8b74c0490b984ac73a8d558750a7f2bb15676e0ceb32b801b70d72ff043b28bf44ff65369119796c747da284a458d72b5f2f75250ee57bbc1da25023060a03e55e91a672ddd50f5b99a19cf5dc5aa2a05fdb586a0db35ba9486d3d974993533f74a2c93fe99bcfdcce1b7b965856c4b57f2bc041281be6db87d18375e8faa047f1ca8737e958ccf592fdf2a25edff41cd299016b8e5d51fce5387ad9faea1185c03f6e8e9fc4be510a13566381f38103ed56286f08d70d2968", + "adc6288b7be64409261c728218d207fe2ebea429439c45aebad69ec71a489f365304d46d18de37d330f366b30425592dbe341739371eef84fda044081f43b423f54fc92404939758b2afa61d132fef460d1fb4230b32feb3133f27bfb955564e2fe2ee26ed13f076de521453e792adb543805dbb18c75f3e5a86ac5beb5483fa367ad36a13a3c9dd77de77a152d95da94650c474204fbd066e9825703089929e5a742b7edcb54d256863a86cd640f140fbfc4162151e8d7d44df62613c17ddeb055ad180d69b48c64fdadd25c3dc82fdb98fcb95f86a84f22a73dedf722a01725922a3bbb1c61415b2bc9d123b0e3bf2a3f6c8eebc2107ac1938300c5700d00c3ab4ce05f3b55ba3562d3aaf975dc9a0025dd5ffc5313a4fd29bb30b094bf64255aa1e605f4f2a7beee02333ecfe53881dbe47433cde3cb4fa6d82a0366bbaf8fd1f1d306f0b313337cf0b9e0ff421659885f5cbb02f801d68b0e3742332b08514fd0c2b5138091df9747fd5eadb0865c5b5b65c97866ff0d31d9a36a5040ae52fcf98c78f89fdfafec7db10a3c5b53f785cf8179d0bcaf9a5b02c27a6e7561f970ca4b5b4209b2a801f56c51aa5c133ae8fbf767e8b57628cc8a1f3f334113ccbbfba55e8c879a4fb5b81f1ff537760902db2b1b764b68204d82db4e638df1eb84082e2cf238f49aec363eb5d29b5704b4cdbab6cfd000fae602c93ec40a78d621c2c594013a2b7349c1ac7bd77a202b4c2a635352459d39f1f87cbcef46319aa7b66a65bfd7156ecb8ad6223cfa50ad4400252bae53d87c7f6faf05e5cd3fe76c825fc8cb73901474204ed08b51263d58c8e12b5d02c3a7b074f0b49ffce5" + ], + "wire": "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" + }, + "keygen_round1": { + "wire": "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" + }, + "mod": { + "a": [ + true, + false, + true, + false, + true, + true, + false, + false, + false, + true, + false, + false, + false, + false, + true, + true, + true, + false, + false, + true, + true, + false, + true, + true, + false, + true, + false, + false, + false, + false, + true, + false, + true, + true, + false, + false, + false, + true, + true, + false, + true, + false, + true, + false, + true, + false, + false, + false, + false, + true, + true, + false, + true, + false, + false, + true, + true, + false, + false, + false, + false, + true, + true, + true, + false, + false, + false, + true, + true, + false, + false, + true, + false, + false, + false, + false, + true, + true, + true, + false + ], + "b": [ + true, + false, + true, + true, + true, + true, + true, + false, + true, + true, + true, + false, + false, + true, + false, + false, + false, + false, + false, + true, + false, + true, + true, + false, + false, + true, + false, + false, + false, + false, + false, + false, + false, + true, + true, + true, + true, + true, + false, + true, + false, + false, + true, + false, + true, + false, + true, + false, + false, + false, + false, + false, + true, + false, + false, + true, + false, + false, + true, + true, + false, + true, + false, + true, + true, + true, + false, + true, + true, + false, + true, + true, + false, + false, + false, + true, + false, + false, + false, + false + ], + "carrier_wire_sha256": "b14b6b08d96aa6d15159ecf8d4c8fba8a55dceb2847610ce62796f48ce93e35f", + "challenge": [ + "8c45f36fadead0125df03a8e4d27f09e6a391805264707d543b43bf6a7753a4fd8f42aba037fad37f7f0d625c103087064ee4f8f8f9b56dd82f72416735306b9d9e904702bc74e60fbd4a53863fc4e793fed242669a23e6dec9a8c1c0a855bfd855d5185b639f9f3e161b1c5a13b009288b9d9ac1a9b2bde9c052c29d131b5aaf1cdf444a0d90fd5025c137661ddc7c8a09ad4a1d3ee12f3961e4a4917f571b8ec4c5d7f5501baf16cc761145c2a54fda10eb43cc8f673f1e738643857d6c2c09ccb311f171a4a2ef27446a81272fb7e084a40a8b52c3e8c7ec94162dc88018f8183564a8e9bcbcc7000d2416eb5b4e8c26ab7324867dcef70dfda63a679e2e5", + "9e200926f6775a215f672eaed7fc53e840225ba1b80a858ed5d994668c8c0e66696254766d3dd02014fc68b93f14fe963621b294d7968b9a0bb9fc23167ea724f185365c8a02ff26143c52a1f2450c6d872bb7cfba0e79b39fedffb37bb17f29f6c4891ccce3e29dd80b4d1422e7bf69e232246533cc2ffc5a513c6e67f05eacd1f020d280e6c3a8aef55b198756b988759a843e545b200b9e2766c369b69518428a122aab2eff8598d325c2f5200b170e1e6621f4e3ee6c25c4aa9127db56d39606236751240d189bc071e31f030639e4ee250e1a5ea5dca8677a670da45ad2d5d630c86657a315fd496799f9457afe2ea3476d9b0ad85f4f50e225435b3ce3", + "6c46d48c0907e8216f0bce8db446a145a4cb74c6f23e3fec8e93f59b2da583df5a8559730e278e79ed48944fdfb63f137c74ab4cffcc56767e461887a940ab3a2a6cd660778a07c9b7cfe8745b50e3f4676cef049122e92e50f6c6e6bb27d70ac37ba3caf0d55fdcfae3de0f12a14ca54e43ac58791dff3c2300fbdc9f13d41c5be63b43b15952a0d5aa192e5175b49f83c629a0958d5c4dc0c8e1a53a21e0ee77ad5dad1bda1566833d614222fefe54c7f5fcfcf4c37b5d66285576f7a4a076ce23d0c5343037b1de78c51bf37d0c85f05ebd042cda4e9373310d78555c2634c3081a5607b2b719420efbe5d94fdad03b554b3169506006aa5a201e234fbc18", + "72d9dd9e5128bba91b1c09bf62b916129684f47bc1452ea964129ae5b42c42e40a1a15250e7ee3fc0e30e1568eb38d8ddae062e9ec595e1d91f18896feae68f5d15f16a9372015a4524b23dd6a44df2b9e5e7f789e86b35cf749c44aa92f6f6d821228467137515d40a057c50dc36e66f0e9524de0f95886d25bd138f51ec9e33778e29a1f2f0eff3c0beece75c0001ff6b30f9886c3f2b75514e3ebed9d9a9492c33524956283121ed9cfc2510cb2780f13a5be78f3c63790c5901cf29e16f927043467af26a8e608b686c198f6558b28f82900ab3c6b1294001a402611a2e33d196db8fd13caba0c2e6ca074de872c3571a3b3d3b538267aee68757a4f320a", + "4ee11f624252cf962c49dfe998a043b58d2db0980b5a0a7dab60ae0aaa9d007c6a8a9661a352c2cb6a169e1eca7071c7c5dde771c57d542341d5d1a378fe7622085f5acccbf75c7f9ad31fe108fe476471e49867b727732cfdc126656858b3ac35a3ee4c615794a9b6ed59617501bb3860c92b94e1c811fb5299e1e1b0a79a1ec8484cc80239a82a9145707f987ddef75d3c227dfe9b3cb70695a01bdcaa47bc5a67cc96847198e7dacf8a5d02873348f59606dab9d249077b67f490282c1a56292440374b520f9c8e63051c8773ced2eac706b0133df48bb1df6f63e76b7d12d1a0f50a162583717863cfdf392a17a34baa04c27ab909d84815f20eaadca35a", + "119a6e85e782a673ed98e89183888631a2547e889e3f9a2768bc98af92b757b01a23e805d3ed5ce20358fb7aec86e674aecb32ea5266d5115bc2f1c407afeaf9e66b82147ddcc885f0defcb427d1ff8ca5b28e031f5d4d19621d8811b6c606e688798a0b283dffd0b336d51eb3e8cd938b786a8526a286d7f3f9c04bb188bab6313114422dd32f31d328a776ef657f0f954b51596e1f3ecb6e698286f24a8ce986d7192abf458224912d751e7525998a0c08f63d36ca39792ff05ee278a4916edb55ea3adb3b867de5c55ef1a25cf0d6790ae5fa022b6bf5091d15bc2a5308672ae80501a05027267d9abac981edb9cf7842fec921ddf355812f03302150f05e", + "9d99648e6c0bcde745cea841c442e0ec9216bc98154dca3fd3cc1ffdd2100d3fc5701c3b84aaef2bfd020c43f20e0280bad7851589fca7b3b52b46cff1b49602ec15f752776efd3057261ed00a030a9e7ef7b5fb33742c8b7ad1f57b41a17dad206a79d071b4e82f93d4fc787abc93d6c2f25dfbd6de802f28099eba5df8f0da827932366a2cb48716d84a73e624356c13608435bcff50a27d628f65e8a913f558c9b0f529f6a168aa0f23d56b082d1682d0ce9ba63d3a89b0a920f6e9c89c2eae028f4fc06147beec5970c420d31c36ff1e009f95cb9a6814a26b2395821171903376d51c28d1dbfa2af848346d0b303229e56b5a99608e9681b74e80835dec", + "1716029ec5a7a66d0fdf2ce6c8caa7dd08ac4dbe9c3ec2c8f538d61cc7469c0e01197270c5ef35dde7aada83082cc6fec8eed6217e5a05b8f77578554617abe18d5b42b383a470db166af5c1a33a4d7ded88a687d4e76164d8e23c9a3c2e8588105bcd5097eb58a332c45d8251040b8454b1d8a077ed27781ecf516f41471a0d35d3d020c3a6db5c4409a178bf478542ac12597c5468d8a139860fb6289fc12af9aa124d7f218cebe4655e7c7ab0a8b2da68368e91b2da8e06029924244589e76576d2aeec261b746ede2a8353ed07673f62177267666bbfc0b8d00fedc8206745106aa50896c73c172131d9df503dce639a84363abd7a1b0a2f8a3d4c2149b7", + "22d432c67f0b77a9a535fffec70b531cf13aff880318064c926c59798ea7b732e43c63e3346eff13aff43b17c9cce6383aaaa3b75bed99eafcddc472a4431495e501a1f12ae1f26f92e87c7409bf7242f2393a5869a5d398495bbe836de3c202f92f59864a2cc9d241430a8eea15128b470a0ca592e6dce6896066b21b21f1db1882cc56aa32d19b9a5dacba81112eb0c908d77d80c8463c8127b57f885a5759fc6c873f97cb96da5f4cc4952153511ecd3fd9509494a773501634b00df09bde3bc8f88193a72b2988cdfedf2921774eacf5199b677e926b5a4ff2b62bda1c4895083beaf250232c0a0ab4bd53df47379049f70f0d38dfec100346bcb516185d", + "2236d855d6544f7b738707b0567de0ee1a168463af3f345240ad802ce55d43e58ce2689928d706e34facc7ba66c2887fa471a08e11345bf53d4b42be5926d659a0d7e8a82947d6b735643e940ff0ac000098c66acb71560704846baf37eb4aadaf50d3546539371a969aa1783905f0e2e81af787a1218c5b61867af77bc0e2ed9c24fe343f9d367d5538348d3b6936647c7d4e3fad3f9b7684ca79a8b97a7772c33d66f76301fdacdfd7a7df335a25a1d4a0486ec30940932a6db168387f0e89bf3f74129ec480f3802e5e28486a568f492302cbf2eaa839ef4a3f43ee5940511e97261ca65abbf2539148c9389ca131037320f081de931ac8aa3a1fdc8b1c5a", + "29f9acb17d2b78fe398a013cbf9e5132b57e475d41aea9e6259a2ed4075ba089a66473c7140e7ac45508c8034f76ccc93794c6d37eb7a9f3563d9af418668be43ef05cbee136d28a510e47ce8e77d8952f4ad2fa7621d9d13aa392b41eedb63d24e0aa990f4041d11a680655725f70975a5688291218f870ce4aaf3f7d89312facbe2babf446bf7aad496fd5610deeba8f0c003f9a2a8e8aecfe71cd966fe7c6a403227eff4d6c7348809978ff291802d4036c1e1646b91a19d011e294bda1eb49944f62d462c680c721c28e32cc5d4fca3f9d5c412b09e102b9e4e8bb69dafd97ccb51cb1258ba2a1f2e9ffc27e98361a687bb505a8a238cc40ee65132a4ac4", + "9c75bdf68fa76abe313a52ed02309de35dc4c11035e77ced1c9d8de2818a4efa1a64bd4733de0027c52a89cec682cfd95b8ca80ad27b6cbbe5d52108897d276cc725eba7f1447f5e319e098da8ce75a27d9d2d239611d3e472a8a7917821bb16592aa709ff004896d2b3b487062336a0650c297d61ae15fdbf21fb293468e69bf9dfdb4de014f22677f8b8ecef4102172a6b21162535a20d43034c8c623c55537f3303a09eb8859c24a802cf904a7ba7f20256d3d4110302da6eaa147a6ae46d5a4a4baae8a5950b4ecba40fbe11cdf071426eb431ccc14b249ec0ed1221ccd3907952716b65fa6ab2a3bde875c8969521ef275f6d138b0f17809cb80c030b68", + "801fc2a4141b50655dd1499c01d23d733c401d799d465f9e1df68417f7dd4f2d2de80deb2869804304678bda3b066ceb9125abc1ec3a289d59ef0933950709cf4192e8f8952e830fa52fff8840272b0c19a3bdde976141e86aa5f1c80e175084b2864bf19c49aceb322b7f47f3226193b4eee5160841fb165e1c84edd523cc093d986e395cfade6214a770d8079b7714d36afe85381cc8f516013265b68287f148ecfcc42ce4d153029fb57716183e39b96adbbfeea8a7f99dba6dc8c13635e9f4cf9632f2f06fdebe9adecd6f103f15e08fe1f206965efbe385f6089072555eb9427df145032cb89b99143304bbddea00affe41a110b862a6667070356e8a7c", + "673d41341e53dfacfdcc7632010c4160215a3345fcbdd53b55ac32bd099f5c4da069fcc72c636c4fed1b686a074c1fcf60eb760431435c1662eae289975897d76d272b4f553a9b461cf0d36400778829e54f59ef2528557b4bce09b08e7e3812e388844604ece012b32a12cc1bb33decd8c41ce9adc8c1348eeb5c83294d813e5396f37324ca7110a7b1c17d2bbe6344c2b8e5487fdb91d8ec31de7256e6269204ac1ea48964238d4592ed794de6492805fa925b014c706968c18f3f4f6276eece08d21b3371727ded7caa05e414220635ce67af0dff68c7f0e2187150367f0396f81213e7fa07656a88f5d9e8a6675c9bfcab4458d5250363ad4c0d0e50e982", + "538fa43aaa4d7471a573df452fcf632e984f91fd98f7224ba1040503144a93124bbaa7df32d4cc9a66dab20c0f82d85c244d8194cc40695bd6b79f24ec9a703f98d121635501d75d719d872a6fb92a8bd3c17d7731dd101cec8e9766a509d228f045b0fcf775ad1f0670869ecfd7709280573db2459312ca47284d4b96b380a4af08e65111c461a555721a48799f0c5955ecb932735df8211717deaa541fb589e1bce1a6a39248d0d352a6fea4805ec00ff140607419c9624fe4881d69f14d5cabee416618164ea4bbd86f3d9e2b56d9c3fd993a923ddae8d8be690f7b45d7bdbabc31c27bfe5eaed1af1371ffc3042d7777301a9e493ffa61ae59c79085008b", + "9197f3f1fe0f0a65e995ea840819d7bda6f33d19c0f022368fe1ee812556541850b7c79aad95fad95525c88b11f5369e8a2732d0b85cede230a8d036b55c2d94c484358fe8bb5ab068a10cf6af8be656b9eb995abd586d3607dc33dae00fb9b46e06b8b1adebd5704bae2a43c000bf9324a239de38317412cb32546a69eb31d9192a8ec54c8f8255a15d8dfbccc6888ba0c44b5e5e1dc034c273c8859ecd2b1ab57e0a1d66ae054da1bd4dcdff395fb7b4787e540a1f7017aff60ea67f88dbd453fa47778869aaf6928b48fa55b957f2f040d124875a7baa9560795b594e4af268eb6e9510538524872763896ec9409c40eb680aa479794fd4d6ebaa8f9eeb", + "7909d038aa9d70da103f518923c518b56401dbee7842ae82286da67ae3659e56326c7e994098f2e2dd2b20f0886cb918758aeb08c9e303266de1095d7e894172b1a9465fe1eed1ac3b22a8bc4f38185dfd3f3f7a1963bfcca475495dcf854fa991d9e591c870b0337454d6f33b8b3ad963e131d3faa9e997faa3888890f89be885133bb614fd3bd7b66f1ff493f65008afa1f53e42746a731cf99e210ba8440c9dd0be6a2286e90a743a9ef54dfa63479260c36b9e5441f849597b15f67533c90194aece05a388bafc4ab24b076ccd84668a43b551d5de0c9915a362b97edcac28a7f283c326088c314a1153d422d735f948b67f2b387acb3e22dccfa1f2b861", + "3026c4e297a2ee444124e22a1d9fd40d012648dd9243e91d5410645419df1d5817de7a6919dc46793a4c176ad109fe806bff1fa42c0375fe8e44e0883d81c29d0d5b457d58c4018a9d3f84d40e7516f523c1e9c3e1c8da4c0b29f17a3e5af73431762bc03a394dba635f8dd0e60d5305d11cd1afd037317ac172093b0a17ce01309f7eb2847f8c49ec2ecd058261a09e4cb0350838138d9ac3e9c297b53a15737d2a82a7417a92d8ad3c18f77075ce02dc62653e7fd6dfafbdd48d7d6b43e70a3e3f86959ff621b0d6515694a992637b89b508689c6f02d74b2b0da2c4d26cff8ec19d4d42672bf1b00efa7316838bdf499b497c71ce8c402cb5d074465e4368", + "81fbd07eac14f9e9f153dcf60f7c9e1a38418c077b9205917ca823d9591e0c188c7cd803f16549e9c39eb1850506977558a5ad957935704b159732c3d547fa58a1ee6442a1d40eff5bcf6c30f1a87b91caf17f3bde48749567d5de93a86c8e551125eece199816cf16339360267d83ddf420e118ae649761973eb0110610af1cd2a971369bf4058eb74a17f83bfb28147d28b0ef0e83f3f4d73538e4021d4aa6b7cb5376115001040eea852ba8cd53530fd4cc886cd4ef01accca2d2684584d36df259d67944b4237200bd8486f47da4d6290455d16586e48fadfc73a371ce684fad640b93eaa98c490a50b7d3dbc94ea5effbd4fa284ec9cd0cf04cdc3eb669", + "833390c217117855d0759781f7f11aa3565810582efb6ef286bf6788dad2e45c6ea68168028cdeb75bbd21e8b0d419a6df44ea14fabbbd5fec8c7ae84abe4d15fb2ec148956c43afd739d55c91fc754727c4a295eafe74a222dafecf24d61800353e5499f46b4b78c42cc0b5814e54fa9d2fda1815ed68b57911d07f6e02fbe4cd4a82de2e0f565b1f7d663786829613f7ed14b545d6a34af073e5b8804a170ece3356c1e6631a3558f22765c7a88b37943a60aab45245e1e69099efbf9aa3e24c164302cbab87d3af166904e2bfea0956fb4400e2f486be31089a68bae5890f271996aca29c4c61d2d8df5aa32776cf0861e146bc1a50dd9b37db37b2bf6768", + "166d9b02bc8065fee8846ff3832d29e5df646bfe9c70f1b5db6ba86217562cd4cd7404fe53548e53c4cb7f74f524caba6f30b94fb18b1538f6086fd0b76e256805a258b80b4a24c9a6e2c21912ff57ff49df19637c5d43c3c6d63a1be7e55b32691ac3abc8beb713c28cb241334b9d9abd5aa04ce1e02b7bfcfb514c3c27556bd1c4b87bfdc263886dbcb628001730a9001ebece876f5ace1f7aab34118451112da18ab3f47e8bd4c230d56f151c30d7ff7de81f32d7b1740619f8ae03dc4d841e3cea99dba1601600220ec3ed0fd76249a8a6f89e2b47f9cd51a062db2df5a1b50e837cb74f5d65c28be33718ee959a289a09b94d25f00923f7a41377ebe404", + "5fdd77449e69382c324ab7489f683872dbf74754b9a7bfd2ead94304d763dc0311f35e620e43897b4423b7acdf8ef2d6ec1af73ff6cf39c047e597d3c2c8ba021924b9d90edcf28b17ee0d3e4364c70f0d1e4302e886b5bea60ea90e0426888ca030cdf9741c1312c5074b3d39d608b24da327ac6054dd1bab03c5e55a02c642a5cb1f3b7a63f1edb7069ca545bd75daf46ac958feced71ae0e19f21e50b681dc1f9948c12036fe1ad5529e5dff29fa3a9829cbe0778a3bb86b0e19751bb66b84c5d9dbea1daf9d2a5204fd4d99653f064993fa7adb26c947725331c78a4f178bcf95b8d563835c738197f39de946530bcd108eee59a45f72b14c66e5dc92fda", + "372dbc5a2108fcae254deb03b260005e5ee3d46fb1269b72afe80af6c6805e6d081f6c3646cec6f15a2d89b30cdbc4d870a626c7946f96c62c3a0990c97e31d6488d2792902884fbfd98d372069a57b94227cbf289e4fdafb8b41718c4ffee06214f18fd23cf28d2055ff07e316cbc5c6f41abdfbd39d4649975d105f74af0784f8ca8bd44dd86b6dea6c21676784a4145b178b6ff0e855d2df9e2abb0d997a6b04518cefb85474a193ef5c7a3f2e8cf911482f27ec9e706cee784a753101d0604274157a40de2e0e3ca9ba7c65fb427dd1a635b19dce6c4b6e0b30b8ebadbabaecdd1c2b9639b78deed3986e0b264f8448e071eb1015bcff8cd02b732dc672", + "4f31a337f137a4e4f996c208110d79e0d3c8a41813abe3f6e647086f7d88175e3e4d0805ee1c839575ca1bb3988b31211863e689dc3e321f10ffe58931a8e506229f29d4e6089b015b00b4dc800c3ad0619cda933e552524447f61ca4e36192307b96a9564f7e3024bfa68c983c3d253e7802ac9ebf7704637a39dacddf23f9c4bb5496be9ceac1f44dd7e434b67f3781ec57248993b8b217f97773f244c9d20b71d569921f7406178005f17c72199a29c4759ad7ad1db2a67a6aedb2109ed80af493b25b013e2999fd91d7a8c34b6c460ab4640fbca1e1c449ddcb729608507abbb4521f9d4980d4adc754a222c174a805b842dbd5acebd691b0fcdc81c305", + "1ec2026b9b18ad1436afe93e00431161b1b674486ff45e685804c6f93329f3a910437b15bf2d813e00952c82a2a73271997708132d97d3d6c35fbea3cf5d6efeedf0f06ff298b20946ffa7f2daa013e27c5706d755826a133060eb37bec73b9ad05e7e671216f5f68616d201a765fa1b5d76703d13e9ca14a2fde29016848151ab06336709bd5ba39d0c73fd5232cc3390a2b81033c4064c870e6d85cf7d228ab367b32955cef7842bae66f29b1dff58b142f05b9cd08a55f38ed63936a037b3cb50f935842b3146161a17c89b45ea65d6de266cfd4580899fa38700d8323f0e58b7247d990904a7b78dfdb4f0b1d689f160c16d479d41293e993dabb46d04d1", + "277ee225cba0cf47dfb290fcd13d4e8a4934a48ef3bbf7c4f7c970514754496a8b58a19fd0c59e50731a1096aebe009424150499667ecee67ad9c9f5bd01eb0f557ac2d8e4adeea2231c1317331a030956c65c57691cd831f13b49657e9d2c6184a367691d3d784ea4ee1fff9ef4153476770a7bf4220daca7a37c93d0888f4aa626ef260b0823999e382c643659000803da4ce565a8cfcbfab4d74d05dcab3fefb9863b6fccbe437b566461f9d045202193588b38252588b296600bee5739c421bce5d609e9030306c0ea7a23b383bf8299a9e356b91932b28224fc02e678021d990f6cfb3a327704bcd3e187e5d883a3760cc0ffbc73933031b72669e9507c", + "237bf00e70e36ec3c715d209b7f8bb9ed90b28b195345ff38e964b143113908c77b23e3ab5ebca926487db52c963ce66c0e8bc5c636a5a7cf702b5fe9e5f81b7ccde039a1a01e0bb614f0dddeb0277c362c6044250c7195cf5b9628e2b8761cd65668c437b1a791f45bf50befd94e64637899dc19113a925e995c925ac2d445f9bef5ecbbc7772740df2474a0ead0454bf9a006eacc11ccb4dd1dbf7fa008aa9b30a329523be7ced17ba035401414659335249585ed2570bcb8ca3a38726ecc866e2b47d42c3f41acdf29cf7cfa3b99883126005d0dc904b7c668d509a825f7af4c0346ba22c551c5b2ed4852b306e7bea043c7a0dd705ad6872bfc22a436a90", + "2227426dc518f7f204db80f99cd666db5d31c1c5da03aef00a5e7072902f85a7fb7f30aa92dcd689514f7491cc97918627356c18d63b93d8e67b36d99b55c0fe4fe9c9ca5f3fdd1fac6427f18d4a6962b07d6beccdb0f6eec39aa2262ebab20e595e162a4fca61422ff3bc176f659573ca49b359aa7928fe91e6eea3f626514cc4e89e88f142c97f6b1a2b4420a04afc0dee4fe204dc8b5121fc37f26f5d0da94fa9d575d68676b23ee7b13e13a01a85d900a74d81eecd510b804e5eb325b17d4e3cf50de7b5b3e7a346823dcb988c66d723ff8a7d72cea58d25d6b7967d1e7ba8b4756ee2b1b36dc515cee5cce22fc10d6a8ac8db212fd40ca174605999b6d", + "4de1512966a7eae43b2e6af315d16bdf07dbc1021e343aef48994d14436a83a102e1bc8aa211db804af6d40f2e3d9e1891354bf99d972ac4306c7a9b312ab07a2ed8f41c98fe213576d754a7c06c980e5b940603376f91db07b88cb2a83ea596e50d51935b18a61680d0e4f74f54ee6c48f999a2e44c7b8435f88db47b32666b33d75cea3d87a86c04f617eb5066c82caa4dc60819e6e2e0ddb8da2c53ed6816be7da12ef662786cbbef8dd534ae8267017865b5debf44aadc28a2bd817f7b77585a7f2fcceaa2bde7eed8548d3f42daf86b590d4b675e34e772d76ddce267b90795c1bcef677db196f147a84d5646f8533170cdb00fdd50a980159cbcb92b4", + "2857ba3c94c7991117abcbb0f8282dd0e1cab596f4bb5501622e50f6e68e70112ee1505ba31370a3b337baf7f126a6eab65b39661af9cb44680cb17069e20e62796aa117ffe6ac8d965f566a936373239d516b0cd93110e8df1f1f8f7ca311ab19abba54bec1a6bc85e7b4fab4ea8370a2dca316f9994f841b5c27bd2b9f199de6ec7dd011e522454530a7a7729977db993c4115b726a002c2dfeb84221d638409343adc026ea4289a5fc23e35ce86b7bdc576879cbc631067aff7f6420c1927c77c3f42a722c5593b851170ed2482144ec8cf29c8d3af95b2cb89fa41cd2458aed846e44f242642006601fbecd81e159b51142a5c186c1d9ba83bbecc97c887", + "38a6cad8e283af68c122caa121e4ae907f381b993966f2b4e150882b9099264bc648c4e813611c1cd63d4beddf9cfa0c07919265340bd327b36c37f6c182815019f746235b858840b85c77575e158048ea12c93949afa3a9b34f847354e0cde1844122e23f989d9fb6e76c1fcb720fac7ebcf9ba54c9dc5f72a21058d5d8b6967bc152d276615a7ffef205a7ffc53d08b45734b1af3cb2a227a250e35d6fedef5f5a90dcb2f52d189f95199df410e335bfbf7e9e16bad8af8a30341274acde92757feb7edd0b6231300ecd94082c313108c5389e81811bc37c505323a9c787948e44e7fd05fbcdf2754968faae9a3c5aed371407dbdc0016f6e8b2569d18d4f3", + "974201af9a4c39b588b73d89b2e27956e3ce936dfb60f9ea44a468ddd5f7a50b6b8c5cd4ef2564cac693dcd9d49e56ad6bdf44b1ff761f3f8c7576ff6d922374cdda8ab0691bf6319dd64670e574e9be8a58f58c32de8ad8ca054e6567a7895f713c9a45af4b54c8e48bcf8d5c2d56dad56d9f4e104d9da8ce09097cb946f486a4217644bc02cdcd0da6e513a5b0bef9f3546f04c6f287502aaf4f3fe39e5d6f659c75572fe31be126472ff60c9bc211d22b1f639c87524497ff9202ef42a9ad9dd912fa1f16eff1999f71116f5ef891c7f5520e1fadb5f3895edba5a3d46324e0e2fafaa2c517c62e0dbe6f935809dc496aced4207547ce8193f598d6c39dd7", + "27d37a627c3995a4bc99df95c5892167426b3e504cd702fada01904eefe0e9cd25af4dc9fce201dac599eb400b9333adcf47ac46a58356c7c05e7c8f7465f345923e59125e0587f1ee428d18b2baacb0453e2b1096a992ccc3aabe8b3c53cdcc4f10c381fe9b8917ef321d36962f368f40b0230c77cb46ec2dc68da2468c83e405ba5e3260c7dd4989806f540d992ac3c780b5dcd6f931f035adc763c4e7b127e9f69e25adc271f9bd5c057a0796ae4fde77824d9f829763d092a331505ace227583a4bcee8fffde242cee4aba729144b4495643531d36e4dc9f52bab15850e2ce044052337526e907d8236d1566b66daa963d355f8883f15a5bdbdb3d0dad0f", + "2dde56f26aa5952a529aaec3608e425dc55aee929718694a3a9084873ec996100b4ca44b9726bc94baf27159162052aae933e7fdb428ac3c3cf06210188786ae11f44584ffadfdc360708917d27dfb0a8bc61658d8a16817f3a5faf6eb45cdb2f75c2904f2328e876ba3b1bbca5b630da3e69f3ab081c2dffcd30e1158cb6e3b2ff378d522d731685a8e8cf4fb63929c8ee0bfe599d9f3097ce93bf8bdfc7920171b987b9573e3833d59633c72dab59b3f019d15cff6346fa9ade6216fbbb3db55d28c8425c29ac498107dfcb62e897e35ea7c6e30f7cd5b7c961b80a7f7c57afa6e909b183e9a5df5ced2af6271e4af5fd79f690fbf90da2ed41345502f3e09", + "5025447341ff279a325976a1eb535f5ade8b954d4a6c06e4c061d0db92dee5d6b5430e452a8ae80f3bad41dd8aeb0c6665c3a13976a094c278db649d7de040c10fdef2b165201f03f7ae772c29cc01ead833cad9f622af30a3069a60df33af1aa9bbec54e590ae0c9fc889839101106851a8d1fece068a938b8df4e824f365116c0507ad1cf4bb52aac6c6345c8503186c886444e78b6ccec46662b020b1fa48c8ad48f92398edff5e0f9b954423a0fc55095c6df26ed540a31f4eeb8d3626957df829ec935f1b89f1e6e9e05f1fd84cd57520b123df0d0b6e15e11227038563a3d8d421c703a1f9b6be1b05ac35e534bd7a9ebb8a2f4a8f52b6e1217c8e45b0", + "1a7ad94b1a576df9b25e486412e0fe5b15a1c624bdb07c2db7d9ec35d29b7f66cf5082123d6ae1b0c6ecdd3c7d86f28249e470beb96c44ce3f20de8a160339b02aed522428c372fedb7efe57fcee1524e233b1492d472e2d68da39917e1d207f0c297b1b69edd7f1b015bb2b76ed51ece80e208f07b485370c39cd1a4e0e8257aa4487bacf9d1f1ad6a3d02942c5e9894ad98b13820bf272c4a122f6f17fb7cfe9c41148b23e57a9036937739448d8a42a3395f7727670759aa220de65ad9c0d2fae7c06ffd4023c5bac7429e0960af0adf7cf67c24977cdf725a8bdf96798711981d84c91232fd9cef46f565ed8b6e3c26e07a8128ecc06c62f6125d52ab7b4", + "68135ecaf4782847560815e0c9b6b9e250a7c26444415a264bde8b333fb2b4f8805b4e7662251bb99949e661ffd289917e87d2ad6d4b9bd5595762c665c7ef455a1098a866931fc4e6eceb0fd8e3d21d7838c87ba4dccc3decc747ebd9b4e7be30999617235940e5d35711c80b228542680ccf59d637d3c9a6711c3dd2330a80b1845df3bbb0aed3dbda48de0fee361a636474bcec0452b27167cf2db5f789ae9e9f1f39e47cef89e13b0a4c798838c1537d3f05a7fb8c865b144bfaca4176defcf8646cf6ed29cd987f4bc8064a881b0893bb2b6cf52c0e7f8227cd4e79f5af0f3937dc87bed7abb360ff0fabc18bd73ad4a4dcf019be5845c785e1e5c57f6a", + "9e75763dd70ff7719f7404e192c196587273a404627df91cfad9feefb7110d1320571b84ceb9ce9658df1dd32ee934e34a3e08f7005437176cb2c3b6bb83101cb0305a00e23cb8f3c8e4322c083d584ba2ee81dfd783669228008062a73a63fa71defce3f6348d7aa1068baf8c1880b84d02425c628fbb92aed178fb4ef9dbc8d3d7c0c5ba74ac6f0c2cd85bc5981843268df21dac290f95221a9ba86c30f705b81d174790a45739514916a3f83a54ef0c488fb5fe3e8fe14353f69c1bf75a1e0284971a965ae03bea6ffa7a58fb567ca29e6024929da935b2c172f463e1802008a6a63269367b15396d9343875b0eb4e9ff077a1af4cc2502d8046b785e8c32", + "a4c53c9405dff8ee7e565084212cb7419d311f121bef8a44e163f22a45970dec0b6cd190f991fd9011bc708627c7e9112f034d38b9dcdde058f0c28351f6a53a29c01cf1cf52719ba79e0c9ccf09c6edb087f86af4bf891cc6d8e025a4509b2d92dc45d7f575dbba568c5fcc3470d4d0378b11ddd4d84fd87746e69945f8fecfe7c293d28dd904410b9e1e3b339ead241143db36957685ef618acfab0cc81b71a100fa82bc0222b52a4048f7c54f56d5d51d1cd1bf0a29a6405727e730be0c15bdfb5543ac984fa564b0f4019bff1fc6cb87e198a7112474783956609d93865b3a9ad0b04d4005ea647bab0a127f59cc4fcb3b5e9c835671062ff3718109059c", + "6d736e10bb5008f8bf4b39d1f4b3594940dff6e4afec74ef88b9475b6b3676d85b9852d91af6b2db75f3ecfc98a392697610128e0bed2a60b579a04e8b197aafa0b9ea281e4b48726a47aebf66043ad9c5487c0459329516af7493ad4b31e01a87ce92130eb111d7d6dd97af592f606e64746fd6887d6797d48324fe496c0daf3c6eed6725c0f3a07fd44d9fb767084607d3ee3a046645140b683c7622c528e11070256295b62ab29d4bc45e80f0911fb3168fceaff556c603ce78ae1c906bcb5a1634046c464609541e930036921bf4ae7d8803d0bd0837a718db82915811b9af780682dc0cec55cbe8389f98f9f87c0df09da329b33a08ac7f730735b2b229", + "46f255ba3f45c00b773117f839c399351b5f0fb5bf3d218d7550e6e11ea9d998c3192d4f745580f52c07d7dc53de13294e099f9f82f1bca5eccf022cee287675057d7735bc6d6c62931ab998968a4a20cbcc89b45a8a6eab0231fc73afbfe095b6a304acb5104e4c5ada398fd683406e6dc8266c414b1bd62bfd77108eed5601f7145646a3fb23b454571c4815290c1ca8bdd8468ac5a0cde1f0606fe1478d32b4a1b15a3b6b1e08de0dcab0680be27a762263a7641b8457e83385a8a95e2ed37fe9877530db3f906506a75a3116bda3fd914ba2bb520b57239d1ba906fd3f76ddd7ec96b766e3fed96204d95b044a8beef84d4f734cdd0b07bccdcbdb0d154", + "3a68434d2ba9b9b6811fce8ff5e47a06505f2b0e85ffb408a897af2c1ba36743b58abbe0bf3d67e62566292f91164dda9bd7bfec072d0df6e60ea2c45efab3b8d5dde1c2a2787aa39ee7c341c24634caf0d31f5549848548d71a16db6a745c13b2256804cb52f6a8513714b19ea846f831085b596afc696d7c4b022b38fdd38c3b3862b83830999da727174609ffe1447818621b93dc9cf729cbd89d0a164055007d31015c96f62a33884fca7655d53898e5826bef2f55e59c823baedc83761b9b343b3cf70d033f92f075a19fa2b8c8750db8d415b60942caac1b00259b9262b89d336009f401489a70b2f582cf877fe37ed8f26d1ce4345f1993f602c2aced", + "5a27794cdda63c6015307d827f405dbb74fd70ead8658b5600c5cea4705ea84201a5e06ac1de838078f522bb0f6f5b2616d569a9b13cb6ff382558b1886be6f56efedd0fa5137c4295690627ddd98062ac9dc8fdaf100968f770dc90a84aa0a269c8be0c1c63595bea31364c6b676e6783e2315eb4a7ff29d1a0aed6aaf940843b812abb27cf379e556fea3bf453944a888c9cdce411975a128f55439494263191c6f64350c42075ccc06b25519057299171329921d697cca359e5f102043be4dd9329880dc7f85bb4f77367c1a8e20cea242ceb20340b92c607d64414651b3ae1980ecc9c6918d71f8da75ebdcfd2d199791928887f23e390534c92495eae5f", + "652813b8d5a6e9807a8c72934a4dceae287d02b84c8dfe2100251e16f3f15df7c5e67f1b4d410364f800bf760f2f4766a6b120042b2610eb128ab2d724f82ffb401eb7406345e79332f16f4f849755fa50c86b21fb12528f553d7e8b21926b008e920eca2ffba58891802415267bd99c494e88aa8d88e6cfcbf92d3b0d8705bd4ba44ce18d9d684a6736cbb58883a950961f99974bad7822dc866497f126d38e4f00bfa9d046ba263d29c8d79c33a2099e9bd8c814e06414c9fea23f67d24eb15af35d93e881e9287634c90ed77865c8fde87a7b36e47399d4badde8f243dfa3d054573e1c71f6cd081c57ab0a8b8b08a4fb21724a2848e2781f3158159bc328", + "696f1145f82b9032d1d61cff160561b9b96947b2cb6badc7374b32f1a990d7c19af9ac6b70fef109a42965bbb9d0218591cec81e67a497e980009abb382ddb5213e076a22d20e4cce86415a0ff8da46a67c98ca5fbab1e13273e32ae67a99d344b480e03a8a0b6a06621bbe663b0e8b2af7d8ac99bed6d040578d42534c1b66ae074d42cfcb43f1899bd596b594f822c12b6d4bd0a510ecbc15e2765e4e0dc84f56e9ad91fd24371fe01e530bb6dac93f4d5930a8938232e57d7da9595dec5ffd1eb3bad9b57b108694f109dbb6a8cecc957f95bad29967b294bd2de0e095380cf035c98c09f1a8d1eefa5d5cf79e8d35e6d656d493e30dcbdd536311a475588", + "6e41b6beeee42d205d1c3733fab36038b495a992505818a331882318f18338af2fb6414d2d6a2fd34bbf0dcb678e72bdfc73af0639a714748ca8600113e9aff25fc37f90ea3db80094974a43edb89ef8ea7d8ba70a16ea690e2f56bb7eec3a9eb965d21cf6269ccd33a1ad4f1c56a5998ed187ac65fb7505b2f955256701501f1188fdd1197c53efe7b71f7ceb970b52cebe8a6c8ffcd8af20e681ce6cb68524bde81ee08e340384583d377d17ea68bd29b0f5f61d6bec83601c8323129a483c98c63d364f68985197d3015219aef3ae9fe984003babb77a45d92423ff0dd5813764c56b8817f004722d653177dabafd9859e6d38b69e889f214520dcb1a7ff3", + "227342d2a4c62370aeffd3b6d6e0ccdc19f0cba921d375bda028e9af2166e028d08f2bc706d4c1942e1a4e439cfe3315a6be8eeae8c78319c782a6951d7cfa943cbe4e6ecb7a8dd87af9749852c05626c18ee5e083d6299c236bf769c34e1fb5de00022a65d8d686017d64d844bc0e5ede0d9d5b6bb280d5c9f1eb0d2e46960e8b40dea17f789b03828155e0195aa30acaa0df248f06a6a9726edeb24281f0df4213cd708a3e911920c80794879130342db9138a3288ce5d07ea90073adf8ce95b93e9bdb6b422ff3b3a089470182049af02d45b0d994f3d25146982bf507e3000a0af5e6d7303ca690cd716400a3298f6239612ea570706c5ee5c770a177159", + "a34b063e8dbdf82c9fba9a395ce1b516b5ec44a639a980fe3d73b5602e20414f3dc135e51af0be3be2b1e2560e390e4f559bf6cc0e9cd58bb6e01140dfa0c6385ff3a2242b9147d98671d56333a435847ee8a831530470e170f3dccec43543f178fae4d5e9b0ec60ae9458de98bdf899a22ad86000cdc088c6f3c5a17acb097f98c5280f64954a465b8b0eef930b360c83cb6164cf587d6cc755a80919135b87abdcf890991fcba3ea4f455818c0d03267c12dcaf92035184da9186baf95f5a7553e21aead558d07b6d8fbfecdaf9df00f9773997644cf41f79240dc2ad69e416a921361e6ae0e7832de1183441981eeba32f0a316bed4e76c08388a7da3cf8e", + "7f5ffb1cf6cf6beef9c22373e52a15ddfc146e5fcacde96f0fa91bd8f52d0f07c20b0927f46210d3f9c9d6e8cb62ccdb1213566eec0920154ad653e58c840fba9c7c8c3b7fa2e4813c5c099ccbf99145b7a0eabd8d569ad8efb1bfb73f3cd9c2c363667ecc7aec26a2f41cca22261e33d2d412d4df38dfc28bc11b48ea0b5a6d3b65f50d07aeaccc5a61d51cfd19329cd98d460c6515cccad8ef3db802cbadbb40b7dd44890d8f7c5af7ea365053affd24dad15af96f64e2e7fb16fa9b844fedc02ad4460e24847b6307713cf076f9ab77bf4a78af2b8603f9b00a91c623097c4ca11484bc9c405b9327fea667f661f66c9345b64efa9ad84b3a2871856ba466", + "440ef9b8f816bd14e35a2aeac9973e9f55e0552f40f56cdcf6a8ce468326dcef671f1a2c4fe6fe655ac5a2bc200b1be606e3b34118efe3d1fc190bc44118f341baf226c2e2976bbccb822d9d9e259ee37b25c3c349dad6b2055c85a6d7b8cc9b005623fc35b9a4c9f280cfd1da464e6651c254011c5f03ffa170ec233162225a24a9f48081418ff583021197d52a89ffbbd89eebc5bfca396415ba0fde713520ff6a489a35dac1aa3b5da05d64fb9ce5592263a1ed55114f23b87edf9da9c930c439e002b1819d9ff1b8cb21f3692553c44123d1c74416ee6a018913fe17d5b142b2425895c85dfa1018f7c4531861318ca19bf59adad7c062aa72201b2a6935", + "2cac193797b7ed964cde062f23c8a34600a408eb149abfe6a54693eaecd6acc98ad419b7e8079f47c2c7ff483eecdb44d2c402de11ce793e5c91b84e946516a310512e7fc3d23a691b859396cb038b047e3a0574eb7a691c11b06f5b19bbf75b6ed79bbdcf58d2ae10955ab2b623863865e7c7e08510c3147f5d2a911e118c8334a8d23a309e9a6a0ec69165aa22b939c4f5350922ca3c07ba49a79f58ac824d4c2b220b470162fabfee10f109858fa959e13f3108c3b247a8549b0e35f74b75705bf7665c6ae2b0ef02516466dd775d057c43f15656a9c49eaf24b1246e9bd66d35f1a2e1888d6ea90d56cfc16faa5532cba9b618b740a334b011a394edf61c", + "57da9de353dd382c5cf2f4a23a9c025e97b544b5faf0b37efb3f4e862bda4d6624254a8727264bcbc3125e03360bdbd54b6953054310e7521a35e60261dc61fcdcc9932f33aa6feec9a9cb342cd781565c21ac97c0c8d62e6af9cf07441dca44f7bb0f8fef04ca9c8a056a3fb45902015b25cd5c4ac3ddea1e66d8f01db793bc1c2b8947bdf6ab429f4e6f753bea9119a533ecf541d137b1258278bba979a3c5d2569adccde26341396ccda9a46645d1be24c40305f1cd4ca6c2b01f47ee3187b19d3fc4e9df618a96fa22ff9bf4f87bb69703a3f4d41a8544fa214e0b8ed2e5e5986f86756aad695734ef1cdeb90c0d2c3fb72bc42fd4c32a414dbcdd5f3ab2", + "4c5039a9675f5d063f23001e6f6fb1fa222041f2f55e70ebd378115c4fcae0bab1a78b9e3c0cb78cdcac6d7f6fbe183696a53296aa8c8d9653625037cad7b16e2d6281f7a5f1bd35fb0f0963da13c4fcbe309061d96c4c0fb2f06b2675e9adbb430a531647da58ae0f11a00197383a26766fe0053e4f71ef1f861976b3e87a0744f3b41f396a015fcf88fb719d933879c3f495f8a301b806ad0fc91232bcf4b57ca4d949631c44c78cc7276dfc7af33a14828c2b93cd0c738c3902f9b33c19af10114d1ec345143219add926a675653d9761cc8c2b5a28f2e5ae78f88859e605c32aa1e519c4d86fb558c1a9c74b738182a3d1520d304d2dc1a30abc79c7d92a", + "3c48bc3ae17ec4f3455e025e189e2adfef7b5dbc9f9282d585150c6032d285fc6b793e7cc1a866743d3cfc24a0df88438cef3301631581bce0149e552e2a3225c8b5d725d072ce84e36e4edc793cdf0f0580d303b59276d0c1262797ecb141022b962751408d4c58d0a75af8ac934fb3102fa826a963d18a370c446c626c58ee4020dd0286615318be7da598117c68c63c65ad27e08344453ff035806e31c69758652a8acb8b3cb8ec096b6759056d19183ff4f1f35b86cdeeb15967a30d4fcbe2d2c75648e3805b8c3617e1e97d1b4af4c73ead3fc50b23ef426f55240b916789226d06576b6809d6814a30fd77a83777b9cb0f0ce775feb2c5004d840367d5", + "db91a6a861dd7f127db6350b8d08f86754d8360d486c8928f452265308c4e04a3bbca28d531ac711d2c804ecb2bf893e6c70ab2cf7c217e03798f150b7a4cf856c4599aceb96ac6527e77331db6e4888d700328d3b80874c632dc81770aa800075ee816746f00943e1265ea79c81bbd263bcbb2d773a7b1c6f84e26997dace810a338fa85e56c4c467ae0176b2b626bd027e7a241884f6b71563dcd67696d6731beb73d71e109a12c1042058ffe6452b121406007a565f1eb531cf82ba824b60ad4f68cadef666d74437e98c5d778ce9f2ac6d392d0acb68bae4b1d62805dcd3adcbd2a797b99d06778285f227f1f8fbcad8cb2938ac38142ed9ccdab03377b", + "68ef390808eca2e3c920006901f8daf0662b253c7b354e89091f75277e8d7d59dc95fa12465eaadbe728867ac5beb7f9c1da87c728e0f8afac8621be1252cddc5a20eb3b2c7fdfe14202a1e11f13d23f32954f596f09076807aa7d744c072f4b5ebe8bef492c81e3855630328b610bb0420cff8ca255a84e65db91f3e788093a34de2290caa58e8f89d315b1fdf5207f863e9204356b32a961cef8344f2afc4d921783261fe04b9011d85d29506c08fb4edb1ca26594bd05a21da656b3e5cba40ced118ba8d9cb987054007fd3a0c7652b4d6c5c06c27200bb51f55aa99c336864f5918a700d2bcf560dc1a337caea96c72b061d44fccc39742f8f121490a812", + "35690bb045cf90ad45aa65b59b6dc790fc50970155c4ec1caafe65caa75482c530aa4d8dad388ee61363c4e0f097db5655b1c62af79e5e86cf1682fce3547055330f9bf9675c0f993fcbb3ca498eb3382c7165def5f7cfe85bd3cc4aeb7c908cadf1726f9954ff8c90119f8895d1574bf873214bb74b9fcacd1ca0c0d87d60da88e23ee3d2b74df9df258d38c6e1301f7b5c5035a24e44a2ee74506a730d651b43e808d49f92368acf3032455317ba13ef75419a44ded409cbb438ecc7be09be8c28a14ab5ada8462bcd98a95d99854653bcd0aec239204e4561db79a872ae69d397e3512a22721c49fe44dd56e807b5a9489ffe4be67047b8b5f3eedb5568a6", + "58a456217ffc159219d2ec93110281cbb9157014e53470bcf68153eae95403ac3417705bdb2294e87e88a20c3b2717fa09c5544a732cd93db7d0de67d180633f5648f756c6a77e6b5f591f1071f306d0d634f9d5c09c789b64b4b00cc2d2c76f105f47a08f25e6760475a3fb56dd9d27256858fb2c20148ae6fcd120c3287671daacca5a208dfa739b7922be08697b4b4935c748e8283a644ad8c95f7795be6a5fc0cde928b20410654a4bd4a10f786f4b4773f7c1f1fb285e1250b9194c7109465cfbdf4e3efd8d8218d2f17e11af11388c2ad766dfc5f7e4bba1095ae164cc11d32df7498d7a6b54c1ef9ac5eb60ad02912fe67f814c25b72d614dc1c116", + "5e6d1fd1386354f37b55a82deb6e33f7edad0d22f2f0abfc34adb44c92ae90146f8735bc6c396a3f5425a243a340a68fd34c5e3bbea3f4e5b107d71ca10bd8cf0ed40445a06b1bda289542a0383c4b94c6ae1fda153c125b2619dd38f36a2ed145a781f0e3d3169a0018c2285e99036edcf399c6a9d741bd212bcaca59e56f995137eb2c867b289a6d00cea4a5315c7e49b8d05d7ea2814bcd24f893b1002a8ad7d5ff1cf05a4b0725dd6b977813a1e30697bb85ec43021adb76ab2e596945d1b25314de8c67e070615b65de9df6a63249ca76b7a60360c4059e1cd6877e659dbe5cc052b1199a6d9f11d823d64c4cb04c619e15e27e022a3e75caa353d6fa6", + "94c45afa6d05bbbf7a848b0b1313f05bd4330651454f455e46a3886e422d25409e44a18c2acb3dff0b205e502c772981585ad6966c4a7ae91042ae6edcd914e6afe23be24c68e083ff64df1b059f9f4acca7271a480c472237f854a59302346500604bf1c6d3713243ebaef5eda42ce0572dce21ff0297ba25296239afa961cfa794981aa2de80d8fac01b2293250c0b7a64b924a3d1a8a534087e197116dbad915057d238cce162fe55c428399258294cb958386f148401f7e4ff10ac9eacefe8e176079f620433bdf3d0509e7ac1cb101b00563ca57974bc0e75a06c348de19bc37ae1ca55798b7b08b9a4ebd7e2877af89945813ef8077a9d9d8aab42d970", + "92b0fe5ddc6f695028eb26fbacfaaff5e0c6438ab6593c7c55a7c3a4ce2f37a7b22f15fb28297639a8046a5e0b55d2ed60386fe87796ff1329745e7347ca64f6ab50ecc2020d32eda288e9e1898a72a9c70bc4b539ad3a12d809b38fe733dc275b3490495df24e6e1d5d13d875e36201c9434f88f462472c4b03a5ac20fa5d4239980cc8f014234f14b48ff9c9d1cd9aca4564d13fc419d9e89a0199d6866e11431bc1db107bb4f1455c8c6f19fb86abe1c95885ca3b9531ee49040d4b665aad15888ddfb6addcf60ec40d4cee4df5c8a130e4bae76cc89fc4e259d9b97a6a62e3ec4984d5a356c594d5fb88527d90807ca558a5a39ed0f39ef52eadb7529690", + "5b92448e4bd06d7dc27528e882d1451bd6f4fe91a13f637f89aed012be1ae580322109636ac3956eb95bc2ddfdcc787b50fc93d1ef91d4ea54337c04a4fba1b05103a1c9cbd3d6af61a9398d8aa442406f288e8380b6b2ea18eef144f45920bc96cbf33d2dfccdac8c10521413cdaab7b10519a512ad911d9793468a319e68d93ea88d1e8c6403f944dd3c1d4e8fb0306764cb86204d8fe5de3218873b330706a2dc04dd0e596ff26fd2ddb18ba7b3d6f0531b55cb12f7dae767048e558ff7c3b2a87be5a20a2ba990c3d9223ac5068696449175ad39c87149b5bca535f7eb8324fa6fbb9636b9aa759b8faf455ce4eb882c05f203e5d18620f9334cbd932242", + "4adc309946a5d73c26913fa16a9e10275a5f246a6a8c95bf89f6a28f8992f1e78e8b036a731ab22d84ac5a3b3ff8e4b79603a9cf5f3e17f9d18da42389a4391da63542bf44dd1be12be3dd9aa0fb8e4acae7b81b7bbebd1728b1298fe08c994b79896db026b6013331ad911f34984e1272797d97eedc4e0a697fe6782323767093e370fca0668e1af5892984be2d1334f0efff37cc1dd3fdf57bff01b0a396435ea5812a6521238b9434276536d853b269fa89d8bd05d7d8d76211bb7be1da918920560e5a675ba4f5391151bbc3448330754ffe16201296f8f4c9042547dcf7aace784670f28c1003cc412517c0f60b3487db5268ef94eb235038f02dcdeeb0", + "3c834fd9a3f00ec4a2476486ca198fa2c25cc8285b57c8db5a6a46328408ce610893403ffd4a1138cf342b5f10fd6a3f16a67973b26becc7f1079fa1999e3d212cd4d8c51629704009b58b8ab06e8c35a122ce984eec77b9cb4d00fce0c3ccdf8697ad6b937ef0f7b4f76d3ba8fc51640aead1d63d702053267e363717e956ce657c48dc9d815ac0abf07cfa739c7d4735e3362b98602c7120e91b6859f4f15c35679816e0c7e40ff30c8d3ed901fac6e470b0e7aa7620f6d1d7487a68b3311324483e68d7dbc36a9d353e34429c39f50e25ef7e1c09b91280146fc3a0963079c9c45b3421202182c836889e10bd11dea8e2d8426b31ff7361cc599c0e3d9fa5", + "1e451a474c9030a6dbdbf19c16f9e8bcec17b6103a7709cdb73309b8d0158695fce90129475465e79afb5d428fc746731e1815145ae8e2440a5e5859b48fda8d34a9a7547cfd1555be8c429ffb0ca59361e7bc7e091715fd52afd4de799f8ef785d711d6e1f0ce45832a60a1ae0db13a3ae1bdcd530b83d2dd3d67470918daf85154fe282260728c20f3440da874b77a56212d55ef5fc9f7926929374d79c85cd1a47aa89e77908aea1fed5724d97b6b69110638d158625d3309a9ab62e7ca12a5faf3f20998be8311e452d19219da049cc8df05df7510caa2f74a00b6ab3e5e0c3fc1573fb76b03f99bd82904ca02e86e9eba0155b45456a674ac35709b7415", + "66c384c5c2b4f5cc82faa90d65e59e902a57705a6f8a6e7fe69c633e7c320ce836c461222391262ca7aaf88e86e2147767ffbfbe3576192d8469784658617637f4283d73fe1dd6fd8b2dc1472c7480c2c2d070194312d00192d83904e4bfa87e4db9b187f8f51775ecbc9641af427c161aa980680936581d6e49f4dfe4a7f93bc7fb675f1aa4712eb5956cdd0c71eb12fce63e2a3d7b1fabc665f27394c5a8387e66130d76f9c3a7fb6c6b779940cb98a67b0f8d838143bcfce738e0772ffafc2ed248a23c277c3f06b5281cbaed545ab7efc2c40ec5180cb37e6de1194fd98266c005ff04cbc2e3b0942c7ac5fbb3dbe2bc0017b12056ab193ed9183bbc61cb", + "9afd95c28ca905004647ec175f2266211d9da18f1c6a19c8a9ace20bf94bafaa2cd00cb89c43d5e850bcd560047a510616c97c464ec9c9ad12fb4557f0370114cd484164eef3c53756f4589a6c1493e54a3962771181a583a2b3679e52d24077e47a1751eeda6010bd902e936deef9646c4d02fb131f0ec948bce553e54196769f9dcb1629903f9c23904476ea7fdaca070d0f7ffb5a3fb4d0c5acdda337177e794200e294d647ea10a7a747fcea876842e50115378f22960a80c642b5af7423c6876ddc358bd20b092b681016f672a43bf987ae066d9d4422d8c72814eb34f190bce7a5fd6ecbde9bd5b389df4e1e1ea08eb996a40dd43e5e7163c16397d5b1", + "4ac72558651b86f6636c229fefbad06bbf00412f7980fce208eb3a20a51555cfd9ca253f0413d7a4c798a89dd30f2be611de9b88b65a1f41aa287afd2c62fad97ada73a46dfefc2c64d491c7f4707f33b59b2ceff9821c87d33c408c7862c483fd29a0626fd56eab9953d2ec123b79f6d6377e58a77da2645c3ae30be43ff0ea692e4aded18a67f83a134958bf1fd2f5b75bf24803bb65e347166ab88f2ff80d1541a634df7f91086599a5d9da1f193a10b689145eb5f4a7310744cacd99908a8d334e4bad411c9de1d52cb9e0455b8859a5d44cc30464fbdac2cb62161c660221c97f9593216c85a77c957fd3f72f0a30123929692d2aa4f059d1136fbf898a", + "a765351db0c5ad5d571b2d3192f781f95a4f75a9525fc91c46c613ccbbaa675c6614487e1e790731c0f59c3c20180623d6639f5d376824dc32b39ef343f2abd17a3715c6606b55c04f324a5bc639920e94a2b4a5619bb56647fc6342c5e1e7db9bb0c977f8df056bf61b73cc22acfd563a20037cb69f9aef9532b90d08378e0949a4d503620d04c73db4b597c641ef4c159bc37a31a738b7f99f4779b5a60e3f2c684da911a9709e2ca05806f046bb3a8681dcd58f8c97193c1a39ee99557fe6d756540e69601d581b5a5c3d87e5b8a2de55279c51e6b7f90657b991fc4313f51e971fbe7e5aade09bd5360c0927589a73d50ab490e03cc1b5d61bcaa245ee24", + "15658626048cb246bf2ccbb8527d266cada8d86bb5a211060880917c9794ebcbdf1d364d8294b8f889e1ba6a22bde27b1d330875c835fc5a5cf660581970bfddcc5f6cc36aba6d6c4eb00ef5567e1f2fe4cf3ae1a23dd791549c9286d7b3486e693ef092da1aa7fe7d387325a42b7d6d9d20d96392f3ad038d38ac3b41d4c53e40aa313f474c1248018603fa38e2ff15867ba3dd571b3c0d99ed9b6fc5a99e582e135eae54be925146e5b826ae55a33ea4affb62b075440d0bb532d980005f0086ea5f955a7cd7e681c1bb23d523d798f8573c555463dcc339fc8f60032a5e8cb6bf64019e8b9fa81554b86b8696c2302ff07b0d26bc218c604c6e388358c19b", + "9e2f89a13d58a4aff366974cdd13a489ba2f51fc41208bdc9532bc31d16c0cd737f0a0363b3dded31cde220d81465d076108fceaedd849824be4932f684ba1aa5a1821b76debe4caac76128f7aaa31d8f714f944f1fcf6ebf284a7ea61a0653fdc70508fde4d1d24d78575f03bf18827d63ae0c406024596bd010f96aa0f33facb4f5c4dbaffbfc584e9de64a51e91343cebc66523589d6a882be129cb9e6fc5945f529d6485f7a3343e5ebc3cba4813be41bedac97787a903e3613bf20452db0f6ecc653c5472ef31e51807d2a543238d7db8081c0406990ae0ebe8bf252f8a85e65fd229c5c10ed1a7b1979e47d7c25fc60ba91674cf05c3ffcdc75377c0dd", + "58aa83d1c3c5398018aabfe6862c3fd0990bc729b6dcab36ea499e1cebd741f4b32640935c00b7579eb3509b2999323b72bd25dffa14ba98e76448bcdbfea1438df26b5b346bf9c827c380c022e04327827d20feaee8600e273a0a80cf28a614785adbf93b338f1554489ffce31c3c844377bd376cd393ddd1a2a3bb43e84fd031a7677ce2fc0eb14fac68e736b932af23fdd8450881da357f2d361e17cceba55464062f9398507c77637ecc9f6fe970e6fc5775bff85b492cf510b802f0aabe2c74279bf5492b3d3de20065b4369e8ba159ce827175c0422e4f481295acb0f22a5f6c37ec79a91f4046596dbeb47a220e5acdc4241d19dea66e14c902dc6d46", + "54a4c30b81c9a1ea9478364e59889fdfcd60953fd6bf4b5c1b4b144fb9f8c0148ba3424945a69281ee9786bab5b63a3618c3210bdecc3bd9d448b718fc3a983632e9f349b89b8344bb72f129a62118b77d81a709e1f6cc950b99dd820511049a14d538ce2732becd6c0b81e9b8416d6417176c72882a0ab16cd8bb8147284684f719be64ed514c1ccbb8994c079661e0c970a57e4aa28077d34285353b36abde1773c842f52d34c1dfa38be3629c04329829ddeb8e570423b73336aa596ad7ba644e0abfbe270c0dee7b992fb3c5799edbf4ad2e02ee3374c05f35d3d098ac6b7050c23d8dceb992beffc7e1c1df320f138519b14c42c127fb4ab69d785463d0", + "433bc1401c81f8cb4f5cf33c2bddaf19f7705c5dbd5c9c4ed827d26a8b345aae7c3b75240c7ba5cb84aa999c907bda8779b64413487f21691d41b70dffb45052dedbc9d387f246f7e05d9662a951ef3dbb901f5a6f2ffe573b56272f90a5cdf55ec7ff099355dd3c290181f08370185a13acec2af0c19b706bed29a23264708a61a767a5e9ee4a62d24dfcd844a16a94602039806be0bd4e61f2aaa5e2324aa06fa250edfc2192690ab376601e54c7aaddcccf7c217a50dce08d812663c3109f7a63450bd3e1108072dcd313b6d0423b4c8cea2e16ab6aeb894979ab77b51b08e62d853c004aa9504bd11c4c716f7a6c2a1b482daf0f5c0b6f6ab7849f7539cd", + "9624cb6ada8ad2f3ea39f9d19d689aa42578cbc1dc3677aeff0a444b98152819d7a26e91f1b512c11b90c5032d91669fa45a8025d03b2c048c483c3b9647bd606a6543018de484ffb871473d5d9a231fd4dc21c8fe4b36e7c8be8fe9f1ed8065d331109e53ddf41483e2c48dc64208a5967429882a7ae0c000bf79aa441379e3592d558f4fcb5669dde32945157438395ba4ea72c77fa5a06a95eccde430a13ce3b4eb738af0d9202421f1e62f642ee58debe748f76a0965c528402817da4dae0ece8924aa8ab6e8e94e1895222033ab0fa1770782251d44c206e7f28d3639326e011271988f686645ada05bd9c2cb823516c58867407b8b39daacd5afde24ad", + "6f71d44ee6b5d17b9371d33be37fc1a0376b1e1400adbf835425a730087c74ce9e0c1751b24f2fb97f75874f37bdc228b986800264ebcf6c59aa3d4d625bd6b85d33c18695c2f77e032bb0e64f91ce5ca3fb40e84dbccfda38f3c89f701c00c3c35887bb1c3e3fe7b256daf4591d3926877a12623a3e28fd401474b0e3c0d40952508d73209a9d84bd5df566b1289873f0f1caa391ea2199cca45256ebc420f14a1a8bb0adf6b39fddf73f9ebf4f0c528d7025c8f66fdc412d8dc0db8626149e9397f8506d34932f8bf412742a4f95f752d95a44cadb3fbd7de58859475e8a1e314642dd0594cdce069cb86e2b6ff8d064e5e6deff7c1d1e610e0efedc9a4cf2", + "95b12c6fd8a533342ce82648f24b031cefe9b95f5273f0b37417a15c22c493099dfe416b042cb22bccd8915eb80c34261a88a9accab55cb98809d8d8cd91888a3a9bdf9519722f5ad7e2f735301c418728b7fafdb2319817726ea2a9373543a0bb90d2a0f57ceeeef1014809901073ed03f1763d05804802f05a8b0c1d939733d333e9736af0b0b9f1e0ac7c5b8c90f08855b42fd5e87b213558d45ffb3043232804461d702c3344cd8f62f75ae34f532ecfc2a7abfb6aaa08e3de661ced813495c1e1c68607b6a10e81c330d12a3f31fea3a2b447f4228fd9d9e8f550f97544b2c752b3bf4f7c4831e89ac835e3823e754994395bbe32b797cb9db657456628", + "1fc76eec02e790e4fe9a8374e831fb062727bb939035e5bcefb690779960535c4485a0eecd65cc7bea2bc6070d3279a3d234a8d62796c998aaf15059fdd5c2f13db64ba585b180434af19f00e1ed504d5b27bdb9595bb27f1b9a93e92a4980dacec289230525b001f04185e9af628483c304e17a27349059c8b2724bfe728d95343757ade9321887558528d9826e5192f06f16f0fe3179c9479b4ebee295c6dc61da721f699d6edddef1a736868ceb2cab42e4130237589d705362ff314b877a39028f1f8dd67eac9ae939225d37743b11ea47ae41ed1412129e41f30f925f0f093472b0ae10e397e3f51ace4bece56b048896f525fc6985281f829653b933be", + "85e549c08e008199a9ebc237df1336c054bb43539637e11d09e87cd4296bf85702247d1ea9aaf7ded3230ffcf28f923fbc3f22bb5176f2a8ab862e060216a885d65c8ecad3000dd0a5595a850e53fdb7933b2742415fb71866c4bf5f558f323b38648308cb2a257c35258481c8c74168752432e9eebf0acd6c48f4cf9af9929885988e50f8907f49ab853504cb0ba0567c887953855b2214e8ddcbac22a6154a295b09663b5c76858a9a509769142b423105e8b35306a942dcb45035fd3b727c7ab68285be0f846d1c822dbc50ba6cda4691847484d65672df1e400de5451f86fdca04dd58e03045d0cefb1a7974e7db64d04f96eb372c3bf5d8995398263c0f", + "7b0757fdedf3027ce994661947bf602cfb9ed033bc72cf3171fd280f1899513a0e80c1e0d404a724eccb0ab88919fac89e1630a8018b75c4717a1255238daa9b5a4f8533e13cee9ba94fdcad6202bd242a09e8e5d74e950334310fe82d57a1610b5294337c770671194e249ac3a893af02de9d80fa7ffc00978c7aa1a26d372d3919ab61821bbc0883e754b4ebab533eb19cd127711c60202eec89b82179dee626bc3fb4f277a21a166738cd60b6b838e7295e27529035494025cd3f2ab7561b8d9378d24a50ac5e4ac1ea55f121dcf1d231c2d13297717e77c2d84280afe0ae884571c7f7f844530bce9b0b37114990937dd0cdc892114cd1b6b0fe977e855a" + ], + "inputs": { + "n": "ab9acc348c6290f126cf3cb35e29b71cef8cf1c98d21f22276d540efb4f2a74a722d2b2ab6fd3e400621de109fa0c82104a6111d476da33c679fd58d32e32551e1f8e4b39fabd9ff7c6e5bf76aa5b7ba72ca79bb72eb68ad72975a6d1cebd0bec34cf56c9cab4d39f6280206b001d6495b6e1c58f3b050be29e078aab5cc45cc201922715dae7f72bc8810380a38c17b7838e6a18b804e2a25d2d22977fa26dc63161130464af47dd5c42dba70a85a0bfa2e3ca4889abb3cdcbecf75165ef6345ef1e58f9929df65ce9bf33a53e8f1ef18c73231c70f21a30c4c21f10693eba687faaf5de5f3b27e020527539b3a8e8358a929bca06c1ff6c3a2720ee19bbcd1" + }, + "w": "56e4278d5e18e72993067a600d455fc1758bfaf87f40b9208db96cca6317a1f59498854dabe973b91b666dbbbf107ceab92731cdba46abf9101ccf1dfe0e9a6ae10f7d4d37ce83f0846436438a75d0441d4b92efee0b65f6bf693a0f9315061a4ee17d6695099fd8aa81956f55563edd1eac4cfbadf69cc8f85b765baa80303e7fa1e61419b76945f3b47d03b86eab57d70a0301091b2ce58c3e42363c9b31df898590ff0efb93292a2f31ed0687ce02bbed8b44c157e8da629668437ecf4045ae7af3e4b766f72b521de9f8745112491ae0fd04bcbc5b5699e34ae085eee549e4151dddc35730aa6380e5e41118a591c1dc7b93fca26fa77456efc115c3d818", + "x": [ + "3d5987fe509b5af875a79c5cdb79bc1ccc4d62c226f324e9570a3bf2afca94d6185aa554f49daf52b2f3c7b5ae73f07113c08c70181315688f751a49920f1edb4f8deaf7abd62d1661557e2ad2550e5befcd5bb93d63f7f60b55e45bd62ac210ca1c12886bdc0d84e6be0b53ec38b6bfa289395f1a27757df84e30fc67ab2f384868190eaf7650c671e2a46bcf7a0264f2ca5c52896159c799afc09c908d84e9ecd6b4cdbb11ac55f53bbad0bfa5329d9dfc5fae7ed8471fa12872db2d3c62d275c405e7a019a53a2b2eaf21ee3c8d8de2d3c0950ab2532b1d33ca432c6446e292757ce5359f500b4cbe80423f66686cb1d4200e65e90f9b95ac10b215cafdff", + "76e3bea020868bc8af3695f7f08cc4e9c0223b56e326dab66d856c6f5f70432b41f8512aa8a7578be121feaa4ed488b60ca43187de2b2f10ec7035fd831ff25c6a75edd079cf5d45c9c404bc5dc8c353ff97480ad92e49cf942680bf3e64c897d4bf054d1e3cdac6730871a51cf93eca3f718cbc5f121b35ec1aa3ca9ab991d365f91590879656d32ea7b5a960283d774ec14a6257b3dcb82e4c9af8cc6149936d06e1cbe0d22e1c9d04a2c4e9719a654e1c340f8adebe9691261317ceabf0da3660c7cdb1259b8a8cb22aca075e5a4d5edbeeefe7c63d0bb9ee9a43edacafbd18e40a76c328e5ddb6865318b7c3e3509c665532072ffb3d3000fd0084181b65", + "6e8c67bb7c396e8a3b78a2ec564849b928870f99e2d7f254347dd4384ae7c5e6889a7481ceb0a08008228c141f7cd7f3264fcb61b5a2f7ce5fe52720c737cad5e2dc6e318f8c3f4d9718c451cf7ebf2a7d3363afc07856c7b0381fccf347d12da85534fcdb569f0640b6d0aa642d9b8a0fc4d469745a81cc8bc551998d14ba7c721c07d49c943f2f961f42d414d802d16ba050ee75f6b6336bafc178900eb12ce1a106ca3e7508f41d7356ffe5394ca9b3d5cfe88e94eefea56f4463479ac824fb04a019ce005b990ba32de11e1ae7a1b00c7209a5e4efb2afe5aa0b6a692bdc412049e7b967b83a055c776afbfdacb388843311dad7abb86f943cc664492753", + "38b8888f28c521b379f3a9278dbe5f80d09b55c9c1ca14aec26191c28713948b08f489d6147a14f68e56b11711fada820d417f6f7897434471265d875de94936f6e5980af4d875f410f0572ba2c5dfa63f114471b2cf86f89ae846c0a6214828991681f96c75a54a0ac51c270911bc7e31eb20c7a3f268567d00ebacf6f282d00501c06067e8e47cd18d46967558415c6d6e738e0bb9bb1d58c1436c5d8b66c4dc4654d00d0255f6851e2138b18271d0dee0c29d750a2f41ed791eb4a12c8682fb5fd8f99d50b45e1a4ecbf202fda0f41f4ef75b3a49c29320c6aa4109e33c755fbe0d72e4da6f28945c422bf4a63630f12fc7818c2e33b11d7fdfa09cf7a47f", + "71c9b07ce8909d5347255ede3ffb2a5be366e02b3d6fbbe7e5f32e58cc7dfd311778d35431d14c2eb3d2b1bfc1fc6affdb75ac9303bcf26b07de7302ba8ed2335c679aba48ebab75c614ab9fb6aef1715a70846d539dd4dddb147fdc131582637e172baf4f0002ed4fd0e6a70d0ee0c37b1928de6436ece2c4c3947b9b8f5597dc3ea8a6030c642eac3991aefff7ac56031d6c503c7a1d81e9e8421f4481525592ee42266e9356bb10175d2275d1536853440e3e038767ab47a5a10f991c53b15c3bb824091399118461b6b4d11036131a8f0d8f831a158215a66f21dbea5666a7a52f7306842389f61a7ee7e088eec1e4a953a17c7374e64827641a790d0883", + "76211d5d07d227d0ca4d2033f0db8b8f5c38450f8af0a25e837c6cce1836cdeacec364791e18908923a8eaf5e7bfb1f3f54afc3665c650fdaebd2add61cb1575c8372a74fde2660b7f98e2aedd0b12df2e7fa65c5aff8474029343cb05141baf46a07787d1cede0b2393b171a76d8a2ab773ed601f4dc4e1221a4a4ca8a870c559153a30c4797bc2c75f361af051a012c27947b98e8c1ee1943efa5d14ba5f3bfbafebcc9a8b9b3b8bbbb58c0b0e8ffa45dc08160f93163e2c875cd41e4e7e485fc50778e24e42ad18b6c5d0be781b3d7406a708e5728a25b2fb66af0aed8e01b691049aa36d3d65005ab39d353d881dd2d27fb42eb51866b40fa9381b89595c", + "2a370721fe11eb3a4150928ae65284bbb1ad673ba3fbd6f6e017715f7544dd464128dea8de9d0ba59ea7f1aec81880fed6103109e035e873dc996aa0eb062ca94a37c7c15911908bc36ceb7ddb522d1a703c9a7e96afc67898b450e2b21c57d774df693c787363443695610597d6e147430043a30915cb1cec365e061d43a34dcee7de5714bb6ccb199363f836f77353487a959d7fd8f529d16c40fcd65b36156859e7de7f229f68464270d21f885bd942a8e7cd41fa7f2d77cc11c286bd2b69693c99121d318f12622216f9db2cdf0e131c7b9fb403eeedf6c4e8531403e7433e3c04453d5e5bb797f9a7fe0f11686dbe2cb7617441ba627a4b31876cf6e4c8", + "350807a8985943a862625d3c80b05afcd8f21b2670f2077f534eda5b9e60522be6c6b5042e24eced2d82a8fa1e4035746ca56c751a9f8891f415701e0933f34a7bc2e7c238ac31ce9cc9ba6b0793cf5a9ea5603fc718683f8f8a613450fb3d52b3174424deb58be0ac36c34f42e1351cc2efcff22cc273062f68996b12915a69488b1df440079295dfa98611d839e426f203567cb5810c0af100859018d9c1f48bea7f4b41459fd12ff2613aa3b28be75c18aaf547c654793da2e29c5b5a3c10f9e791c67e13ebf71e51c70a21b3b5195789011e98501fbd8b6280faafa06fbc76c7be5408699deb4e071abc25d8dcad875db06dfbad2afe1b1ca1ffae0bede", + "202b0c9e94407d05d87fd1a58b2f0d99167ff4bda169f12bc35ead38b67c387215bb7e641940ff376475e892cfa9ea730e1ce5ac460a706b6307aba512ba2eb3d82927504421038d304228f8e39792605bf89adaaa7496107450c991895c9d08024912673139f1ee4aeb1e2608320a4c3837c5d5209ef96bdb70b63abfe60a30f5eeaea2c1908650a3220191929ad81b7b3f7b7f3b42f6fb93eb21fc00311072f6295fc5b80754ec69ad2e5ca9aa8db29aa948c783917c94c2830194f7257c0fc1ff2e2a788119f87936ffb524e3b3a8f34a45b6ab3fea93d883ac6fc240b8fa3026241ac77a99bccd806c59425c1ee2c14a50dd94d350d9c9a9cb764fa11225", + "3c0e22871c7a4ec6ebd6b00320c204f7a08f5b48a4c72a839fe9af8f810f92a747b95409c930008d1a9854d9ed444dca0cd5c2d6c9e33a9f56ba2abb657f7266338dc6280de992b717ded5e73341bfe83d59c9a82feb7075fd993ad734e1e410451ccc60c81851a0929757d528da0b7e3bcfda2a261623ebfa27f14720eb07bc04ac4a5be5ffd052644be12f45b84b81f849609df9404840d7c4325ba396c6fea46023815af25b67747189197f1a368a9e309e6afd568a13813d1a4ef69db08e80644ca45604e3928567a137e0616518d443621672ced35fcbc778c4c4c472a418ea7fe354ded784968e7964b55bf38e6255a2422e3a1e7c11d405aae4ada499", + "9f5d17d1e6e8fc417a23cc54337e280969b9d8481a257c85066228f58cd2d471260a8ff4095530ef2e590ef27e889232c7884af80e4fff63b8af0f60101e1d7191845d0c7d28b17444bb7a62716a351fd4892d5d4c57225447256437602811a661fa0e21591462370fc4bc0c4a9bfefca48947638d1eaf09f0196a87254e96c79f0334b49d8de3ecb237c820b17165c4bb3804dbeb27a04f82013dcc9ababd143c4a5ef382b303e7ee28431ac2d69ff5ac7889a07def1ce7f02914c76e42fd54df97738ee390f3412039fb03a1702f55e9ceae635ac5de81a948f1e884c11122b90aea7e6e922a1ae72d104b081d8fe854bf394f7b5b3fb3e8cc77b832e5036e", + "3b12b9837e9f40e42b46d0843e9b4caf138c76c7a386eae925ad9e3e1aad67f498e1c94b16192ebadc3e917a5cfa2502fdaaf947a0246e92c141660c7e06c15695e282c507618cfad016393a6fdcc12371878b54c20f51388983bbdbb65dba5e6a09517f0072f0a25756837969fd30f34db2e17bb312d78b530b61d777a502b629c789ea36b723cc67e22f626367ad95c144463aba8729925c35d4556c19cf39a7c860a5bcb1f67bd6d880432145090666c3ba93030bfe751348f9c487d2caeb62eda5388b2357e9952aa788d197e5a1ebee6dcbbf64e4a7d3cbbf5f98a6e179fb2c52b510927736f00a20052fa53a7f9f8a6fb76d5e272c0a4babc01d5f4d09", + "377256e2337639403d440fd4ac34aa36906ec567d50a812e37e7f0e6f71f64528ed1187c943301033098babf37d11d68121cd745c7e25fae2330d747cbff7194d1d6da1df5666254ba08e55ece72b4592e363775d15ca85be7b4e872794ce61203d41d06d4a39bb29ab0b03ac7b5e0284a7be2659f3a38b27efbf5bd7ebc314a169e3d8ac62d05dd168f64a3df01a2e24299db4d225e0e7976dff916535c4dd31292ed6f16b3bdc3d4061aa5b5e44e810144d08153c6cfa4bc550b923c910f3ad08ee97b0413e9889a9c895059ace4bc7617e017305bdd4aacb0469acb3608c13c8c92d8e0d4950529c2ce15b1386520e14784cb6081a276be27adfcbddbc0ce", + "35ad6c0107b0f46b4ee8fc503601c6a4ef55d1a8defe092b00c01562f02a4a8a2d1fc5cdb772908982e77217a18d322ee2725c44ad47f5ed466887499b4efa3b9661df83abfe3340ba35f986e397769dc9851c5e7a0849ae813f26389cd09d8542e4d0b843de2c5b4fa08a04d02a8a46002ab127921534f6a515dad4e1999628e987c7bdc447d5b5bf01301b619df7f56ef151e194181caef49260f30b040bab431019e1f561808c38c8656a9c309543a7e5f440b3ae2af21519613c2876646d590b0bacacc100ab4bcb9061e5c5875025cf24c0daeb56f2aed9c4bb89d6e9b7e2dff4b5aa560cb04ca8eca24d30788416d55b4473ec0055c93aa78383567ed5", + "67284b4829dc8b185fe87037bfe574ef827d1025e88c31cdf4d2d2dbb1401d5c60abf9efdfe3c2a836d78227ed8342bb776c13953b4ea7def042954e420931026856595f137072982d52c8b0560fb641c466a3fb0869effe03ed0c24c2f99e7086f0fa079559db22cb3dd1d72d97fcb0c05561da356784e340e8beb52e7b39786de22e8bff73e9d5c7f8fbe12d9e111b6453370b93939cc5af5c66c53c79fbbc35c77cdc4e6681eced63c8040ac3cec18a1475769da1ce9e5eae8a5cc562a189d6c09a0f19adbfce3d91925aad7cea4ed87fb0026cb6b2123d14bcebc36ee75c0ac25879bca7e8de02548d19d72041094c60c138cfa2cd3b994849083941b7b4", + "26be3e0933b148ae6d51fceda78bb5166cbf49d11346e9818eb3b3e11cb418b3dce5f5536563ddc904638b18ef128d2fc036dd5cebb9db695034cca44eb637694b9fcae30fc1b6bf608616246e373bdbe197071106fb83b99aaeb351a4056ce81585e1d537bcdfdb7ab902093608a7168e8f303a1af760d499e38274d798eb6bdaa8a2f5c0f16bcd9baedf74e43abd111a3ffa953c85bce1ae80dbb5d42914ce391b5c083709863f51ed36343afaf973f64703f017d1594426aa14e52632a298b09c95c09ddbd796b28db40153447fdeea608091d211e907c60d7b260702fa63ec3c56df599bfbdd748cbe7f8a31adc27c3252c94b619ab376f7a826751a7dd2", + "78dc329784b37b593ebe21cfb909042acf70f3f279df4826109e152367c84233a88574bf73aa46a62f5bfc1a782f547355304de11bfef4d1d71e6b940767b0b28678f7e229f97e0c42712cb378601c3fb08e649fe42aa02c2c111ffdd305b3ef14208965a450ced77eda84d606815cde7bb4f76d946b20a6afb25802d60a301583ad902a2fd7df3b7b16203a689fa970bd21270e199b71dee9eccc34ed535336ca3734bbb0dce065d67a6507d8796e685312e5ac8394b826c5ccf51c7961887b3ae56af29c17fee694a391ab7c911395f21fabb386fe57c107d42c6dfd8533ed982738f3d12cce048bff8e81e8af309181a96722990da49f0da0f040c00a6383", + "367169e63916195dbb81580c116f0657f678a43532b56f132ad0354bb1417468588f045580d913b6bb33dc1b5214b7ff4b93184c1f605ac2930594fd31d7dfc27f832e843a04b47595486dac642a1698c50966b5a8bf8837dbc055e7f728a4f636af7a338bdf1b7cc726de42fecbe2b7bd830de7a682f703b96f1b434ff63fd8df329fb949c9bb4c632feee7d314e606e27bf83174b00531035b2957008d491ec8a221736c6a134914c9026bf8e5c25e9a3ee67d80bb6f9eb5cf1ac31c4ef57ebf3270abc5e14ad2635643b99a9b5621a5d59af46b0dd98926c53914d5622f00effca8982c0d1f7b2c56fce1504b77604a85c9646e3e8b6aa8d8365af5410553", + "5541c831c15b18a4c30e77e85d8683f1d4da6aee3b2c5e421ad52eba369ff7f6807e6171f4dfe9cc6689d577e66961b5684d6f0e7749092c8473291e94b1ac51385608415adecc4dd2535508a4ec5ca0c30c2a012c170c6ab9904e9ba0610a1666546d5cda8631113b9c5df4d5818f960d15700f9d4c0cdf272131b4f2db8a240a041a6bfeaff8eb40320962e0eaf5f88a2144bce376c38c0a4d621cc53b05a547f7d264af0fd10b87f4b95886f2f54faf42b1beabaa74556d97e641e1a8f2627284c7189489e51beeac31ebc0811498f8a8b182fcc0613369b3506e268219b1d83d65065347c810dc08b50e0fd60c66fd132a9163bdaf5b50a174a5081acafd", + "828981f7745317ec00f57aaef1176fdcb9d9f973941f743580f34daff77a3d07ee794609d20d317ae03c67c0f942624c04bf087a8ac6f647ed12a2c6ab2575b7d5c1feca9ffabb35a57f46fcf82d6b527c4f2bb333daf5fec37e90b8ea83918160eb78f4e4c47b6a4f00b52df908ae190300cd15a37a77c442e32550b3bdb0d296b26c4c39800e56a2d6c4d6c4587c52d21a16d8473dc42aa5afa370bd1c0d3209a86d7f1236758e5144069edf7194afa154c7a33e3479ab958044f91ee62d3a21b40461c38fe7b9bae5231eafd30dda5bc3903867fddd142b33d2c9844990638f1521a58102704fc55cf48c1c6cee0b49f955fdac3152ddb6617a1742467ae8", + "2ad68b03c5cc5cf383f0d9f18c54b882188683ef0031510b5bbfee66bd37255883ae920edaa4b3b4e78b3c471eda2758acbc757b770dddac770b38e2219fa916266b1205178994cff9e8a842c0dd9548c5e6f0be8550887aba6105850aefd7d64b6e7fe9ec5236412baf964d7865a8d8fee7f86e1797aa83658a7a9143499a2b86f2847f079a4918d75dddaadde23fb4297467667cba66b8d8d09f772f8d2b5b6257edec1ed7f7f44bfea2e70a6908b105ca0f3b6146e7a70b441812ad477e02c3a9838bf12c2e28bf8974f458b933ab56b67cca016ae104dd5b8c9b355d23de5d190b54ccf7b697c942249bcf3637d0e49df91c308621ecc03be45bd8944cfa", + "4b824a40b8541bb1c11890e3f855c5cee53f6d7d368027b659d7ed5a2dde00ce814adff5773f127baf3e38c5880c3644fc27594fdf295d3383021af47f93004fbcedcfb86346c485957388b08a36f1c8b15a88d4649ba7463de77cce4a1e6318f14b03d3d5639c5af96bd5349686c50757c957b344bd180c1cbdf22c514ea40fb28685a0f532ee300ccd38927f68763ac37b5a7bf587d80a8f19879e593f8121eaef7d457d72e9a50ce98a3a1ede47ba3ec785047e96a70bb7f35972b797a90b22cc414c0ee0e9393125d65d5895873e46b917d97352dd5c7b6ea63733f99e93b8324976a45a5b993ba7fdc947d0e5f02531ae8e5feed4824f44f9dc0a6764c6", + "17f65301bff1a20d2330078705d3d19974c657097deb2fae2b11f553e098c22c5ef8d3066cf1bc259aa153f5b60c062484ad546d17e8bc8e83415b1598374991dc1a3291d59dcc153e0d5e5028b35da7f355119af7ef1be76ec621b017739b224ba3f223be4b7782829dbd5d7b6c56bcd483b2b2e59c4c6ec6b33effc34063d4e6099029a0b2bc55ededf3b7dede462775a51e2b4af0d4f3817c456b49f100b7058099bc70e7ebdb338d653ae5f47092d2f6724be045a31af182b9387e427d6a27275242b932e8c55285547ba122cb9cb8081ddeb8114fe94b68772d03f8559d5b2bc467ea2a35f7be054e2bfd4a8f370637f7d4e8ea5e7ae472b9b25090bbb9", + "7e170b90620b2494bb11f9983f6a0580a97972e1b8cad82c30d47a5985ccc84859d8e3dbecd958ed466f435846159d3f6416f7cd6c6cfff95179dafac1420c92ea2c73aab6c6a6d64908f1657b0ad09d290c0d6e30a5a73cd2554b28f93665237119e2355dfe6ab7aa03d88c9ccba8f20fc4b117e86c943e3fdf3c2df7e73165796ffff5c4c150900497400d8f758a53af8ce52564ec0608394bb88e5c192cb50bf2bafabc9529545b31c52571b8d22639e7c5d692974ca62b4d337e8d5fe3bab298f34d6f9526faa5753ebab177de41f25b91f058c6edc561049772a44dcbc8932a284bd0ca1f10550535efc30247d8b26805e79a28b9097574ab6b40cfd40c", + "7823c187b15f0835a73ea1ae53bd6ba91db9484a9a49e7480f53f5119dd88a6c1004cbda3714fc31f4dc1df98801e21794fbd4e579541d0c9f1f3ef554722efd085716cf1bc7376f60c13e6c3e29668b5b9ab4ad0717517fdcf9e9dc78fc06df77e4b1e9e5f40e0a801cf10703de33f7f952c28731c3322ab0e7b8a2cd4c124c359b9e3d3ca370f186c9ac972e5b57d290691983fc8ccc0aa4851c38b29d2647830d385ddc6cb384a2359db0ef5c45d8aa5b90a0f59cda1e63665f68bad1a9a8e3444faedc4bd0c35d0f30ee207c767501730b87e8c8aae70518b60a014686a37f231b6f003e0b5e06e01e981615a67ef6026c204832702a3e9d154f62da0c9a", + "35099747a6e63d8cc61ce39c9c574e6a899d94ecda14c2a3343f67590ccacd310196191454c7db8530774c9108a755836afb2432a80e33176098e8c3bae0f0dd73119b9541a21960ed02a524066a48b5d53eecc1766d4bb8a973904a2b2ca5184770a8d9f3a77793376e5378417a6a16dac10789f5a46ab3a83651f49d60b4c2f582212bb5b32b2149ab836e35ce35e355a5c7115fac68a79458bd3c13fd9245be222e2db0755e9519e080688dc232bd60ed985652f61ae96994b06792006fb33a55b3f5fa14a13543f1b5d076cb1f487740b3f5a883fadac80fd8d82cc61409591f5d4dbe9f0c998709df36e4183c4dad54502e8f6d4a16fcc5c1e796c2ef86", + "511ebbd889ef054bb614f0d765c2b6b8b25edf51ee8e319b2d270fef136f2588d12dc81da9fac7eee1380266b14fc53974ee09a8d3f54bca179b4658e5401aed77265efeaa1855c19a623275339ea629b9f1b9a3a4dea48719febeba9bf457166a6fa783f9930830e9dbc40deff11995371646100548ca43b742cdea7ca6e4affd03dfdc6539da639511f2831e0fea4c564d166ce8559c47fd6405d97cb1aabfbcce0dbfe3c8d0a230b2f8c1e6d3ebf4c93f22d211debcacf3828e7c448a7e9d5ee1825ea8cec515344c728bda2354e5ae1af329bc62d4ac21551be41bbd4dd5230ee8ed78040a49109d36f8a1e7444690faa00021bb0334fd0aac3c58b8aef4", + "29478d6d516a7771c9497bdd02df3b709c7a345549c44b72d3842a646eff80fd248f60d3f7d6baf38bf40154410df8c68ec8fba2ffa6c8c2632d401205a57935155ab8a69e939b00103697aca6b8e0a2c356bbac275ef556ad592c5e492401415c6377d7fc4616b85453936a5490db42cb563a9007fb47fc2d0a1813c709b45c8112e9cdd35257413913196e06f521a316687e15ce9c9c323d09051ef8d9c8188ba14c9f9487176c331a8313f838af29768e68056150e3b244a5899aebaa480a1a71630ace6fa05ba7f78504f3b88e987ec858379a526bd9c2fde695fb1e11b27e92efb263fdc4c7490a78474e15bd5682c1054a0754deff44fbd0db26424139", + "2cf73e4e9238e1512e525df46222746801a72b0b0e2b311abcdd5d254176a575869a3e61bde927769b1c56bd84ecbd3f28e30ffb74f31fc0b09ec665f0de90289a1149e2349e20bc55d2767b464f239df9504709980edbe9d14b0a92126ab52c5033c573993cb77d6c126eeea2ae66788279775f31dabdb5e61d422850aa646ab7251de33b49f457ca0a07c53d1df79b3300ad447081c72b13eb24329c6de948eeb9a7a88906c2e688adbdb07c2bd21aee4ffa2a981801868b422736536b0bb4e192727e05d3754fc69e7db151fccce3cf2b5893d45da0c5a660791a5e76bb6f21fc529bca627a0a67207e6bfae2b7977a332d9ae3abd9c38c1e02a1dc7f0330", + "28a2f7264ea8c4706ee9e8e7efdb92b5b8448e0cece16f627ef9a2d0a75d2a99a678607420b4c93664c1f093bfb7f71a14f92757d1b45a2a06c95aa3ba0311023876edbf150cc089e2f7de037c190ad7720eb653e17a12ce70ae959e9c39fc2cdbacf13ebef9972461eb21c848cf633e9126c3da02a26cd3737f49c5b612662e61ea929a877057b13b5c6b611988c83f24d25be98707985b910f88b19ed17d719b3b23330c1864676d0ce447a05879747d7b7a5f411c30d6e6c42da12eed48e6a5ff98fbcb5f3d13445591cfe1ff3ef3d1bcef687df5a6337704a2d710c9a75158ea9b2207e818a4f35c0be59e871329df90bb2c328974d212599110863d1e99", + "663540c60ca2a4648e150eca8eaf43f8d4c62e54d4d0c558b96d722b6287fe26eb504b6fbb25b36d4cf3a535ba2014b69b5745b758ca7a00d8169e37acaa376860117390d8ba914204659387e97806669b34010041257cc158493b5adffdb1f0b0d713ef2fabe01d43fd9cc10ea4f84705c49de6b3e05f3256c71d425053d654f20ec5e546b948fd9a3fa45c154358f636bfba2979af9d33b11e832f5bc67d9701e31ae1f344ac4d90b70beaacc5421dbcf1de5635af44163975aaeb10b2591cef39388c552f6d06ff27d5009f501b55d008fa522a9f57da453a6fe16d5f499e8364859a68e23710a76f274f02834952f49138488d62ef2bd4db9487aef76f80", + "344729f8c0c10703f1988a16f9d40af318efabb73a445837d8cf55a5ee62329a05c833f677eef0fd87fa0c9f2cf77269f34032434ba8c909ec65febb76fd36ce1e7e4fd54d3efdc400e06562c11c4813f912d24378afadccc7f7f46c3eed29c0dd406923692a1d782a2ff7a7894b2c81a7f2cb2a2cab9f3e078bbafa45b184ef730be0c46c8be02fa5b0f2c5ecb011e86e95fa8b289ca3699d3001e7b91f18aebdce048db98c342d475be15a514f0503740621e6d489ec2399652e0ce07e69aec9ba11c74e2b17c953cb64011ff0332fb968b543f38874049c3ff87b7db523ca93303b14e29e27c85789ebc29805ca3bdf9417053afda63750baee4d3590a862", + "43c49c72215ea2ec770698de647c2eb0847322570ec70a05fcc3988acccc1b5d08a6a5883468f6be263428ccf55744b3b7d5f45362ab53924110207d29524fb66506fb748cec75314e128177c15fa7e11a0d51a76c1f2bbb23fd739e1ece7c16077faa747966062960519bd629635ca892183ebbcb226dd6614b32b60bd6177419d1bb7516629eab9400fc4f76b9ad17486fce9a5ac8e2e2222dd88b93ebd953a150b12023b0cf336dbdc1364e6a86403d7bd962d3f023ab18a78717b708ccf97cc70981ac42c52df4827859ac1ecf56b12e982f2ece6db9130dd8106bbd156f796694dd439ed7cd50761d75f6adb062ed78bdf56867f6d2f8b8ad0d0f1fdf9f", + "1f453ee7d5935f3f41b94307ad482905e498f756fa22316cc293dd5a5a0169751ad685cbbc1f094f44b3b8b645bb2e910749ea540513968411fba91eb3b6bd6e37f96a2518902f5a95ed75b114e5044bf514e10381f360fc5a4ddb211ffa6b2caa3b1e8e4f14e4bfff8ae2380afdb544aade2ad79c5a82bafd6b6393d14347fc4e4db92b0eeb7db9eb97f20ed91d2b52e242623876421618c06bcc77761510e51c01b9fb325221b4cc95eba08776e91eb5164c049dc04435e0d506cfc2723ad0874d53b48a37c7ba77985d469941b9dc4d660fd8ff7ed217be62710fab2504dda5c66dc5e4433824f4c427c4ae9bcc33a91074f860b7767ec3396424a623d681", + "441daa103d8d31230be31b2858e21157b189cee71729f2fbcc63c9fcc6481e7754cc7cefe346cebd1f97e95fb30febe260662ca41592c78b533bad8597fa1d96e5aa90be15489924dd7ae237076b3d57f5e6faf01e553d6df2ae1cee83afe75e0307d9290893bd77f2b81815a556bcc69ed62c90d87bd32df05a417bbe8c135d04e9a763a9c2fe31d894d9911bd9f06981a2e0c07feec516b3f4db60f0e2edb86378cb92f3ddcaec876e33f32d59d346bb23a301b81f9492872facc61530078a7b7a620510165d590165d8515a07a1ea738e335a9db45e160025a94b541b59b091753ff4a33ec175648f0f3d541df2de2f0931f3c302c485353a61709687f431", + "840c621babc1abf61828b2118521aa64522e00a2940516f92f9a180966fa00a8073f01d0b2c8b60666c5624c8d5d3a942f1b0533f287e59ca770a97e0591264af5be0b58b4c9d380a08d7805673176ccbf796cca8936073fafbcb1d62d706aa1e2f38749dcc517c195c1e48204e3585e38517323035b9273b52d7e086a60381f284eab32076d00c47a1ca6191d8d03bca1e7aa5f5ee9ce7d6c4f997bc7c7d97df6bdf8c6825289a4e420e54a277087c14cf1c6a4c0b02f5f028b70b95fe7ebe7d6e4423e8c4c88cc134567cdc9c5ba67cf4c723ee800312b87d0f73e8aabfc926dba6b7b4a42d919e5bd6748951c2c15e2572f496a593dad3264a29cea9ff9bb", + "678bcfc408e57af7d328ac78a8eb2cea14c7dbf68182ed6827138daeac4c9ce84fc68f5ea1cb473daa5598534833ff0b3830176eb3249670cb0f789a58f0d397cf0beff409f4dc239f36e0280ee649b9300a560eb54008b4fc019a6978741c74ae0348bba68ab029ed1faa7f2e46cca416bfe698cb3c0cecd57b16c9421432629ac3fc8f3dbf5abb22879a121f15d03acf43172b826cbf5bb5bf2604548dd3c9ce649e66098de5fd360c7510652efef3469f1a8bf142f60953aed6378a129fcb5abe30228151883de675018bf090d02e00bfeeeb8c10cb9f50a927b8a09ccd2dbd5ef4e2a7dcc7653fe56beb77c7e89c999f2354c8123f88b679cd0b0e323b84", + "1e4d5b13baf744c28bf9d39af65102ffa477372b203360ad2b7cf1c0f07945d545259d3297d1497c3ee1d717da1ea86ee7ac1cef18b8066b2bf6fb536fd734a1e12b521a746ba9fc483ac8c03e85a40c2bd2ceba96168c7ae2fb3a5521ea3290e0142a7da3736e5d48bc02e12b100ae415ed3d3056ec555de880fe5ba06ed2458570e6f8869f365cc2289db2bcfd3be1cd4922ae21d57ddc9cc7e9c215c6b3cb5949d472e2684f01253b77001747e043e466e8942079aa35ee593d6f97bf3614cf00bc8711eee20cbcbeeb2166d38f6074be64a765bdb637d96b15c093237b38c7d22691eabfa53246d48bcf6ff9d4ff471d71fda1f53de51e4b3ddd2e5cf929", + "e6720efb1926d1788c3b08b73fe0a23426b402139d439eae126c5a9f210ec5a66c959daca4c1f328d88a133ce7e8d1b7fea592cbac8865e9c6669186a73557a8e269d4e2fd01d97e7e027dd91a3e608052f08e28cffc58f98f199ea9701fe70b6d5e81f24430535566984f8e8c168ed1ae71d50d8d98fe57eb05ca05acc78fd9464018cb03bcaf74753b7aae0bb6188b9a32f146c721f75f7c8810da02dc1e4a8806ded9d408ddb6f6c9e622e29c3208c78f72a0a5a4f93be44f84857327e764a7bb42ed8d72c91568994fe5a3900abafe25089ad19e1fdaccf299406d5492484bf66180a5c5524e7631dfd53ff0a83d2c92a58e9061ebe83135ebf450b3d3c", + "a3dc2735bbb84441ed16c37298aa262294f8ff75f4e13f1343844c07479105c98f5fe5757e204f2bbdc0686280f2810e3ff98c5b5afc9a668ef5b540478f320d47055078839cd184ed4f0d4aa547aa3c6f3f9c33c33af97a71ebf055de8fbcfa55240ad792fd501087f93e4c25dd0915596eb2f82538b1ccd2ffbb86ad3c5a62a82b46ad2758ad35b383a6e7a43f24ef9577018a626389323694563885335d8ac5a53a11720fce36719e4036cb9d2d9826964f0af5d2f2a07f51654e9afee3b066d34477569b20f2b8ad8d03d4d7c6f850ef3ba13efe8241f8928e32727d8ecea5f8d0f8e0b958b22d0a7decc53d415420cb751d3ca1f71f622ab8fe7bf4828b", + "41879ade1f3e346ed4bccc6762ffee1c2248b775d9d3fc857bf50423d015fb98291829ed150e11f1def93158cef447e4e6b2b9b7824cebeb876dd198009ab824f30e04a24ecbc484725b60a8e7d36a5ba59115743c306cefe486028cab0a1903c505978b8d1e9bb90c1e2ab42fd3e786f8721c74c4b81544b6e985d65b1688ad5060a7ceca18a0bdd7ee7b69d63339ac8b31dd2077de1192f8ea2ebdd5c48419205ba6b005712e70abe70b3627eb9d667604c28c861eab2ba73e708a1bc12b2a329b983709960c0db9381eda939748d118d0a6164f7b999fddc187a7e3a4a06a2c40b8a1375eea8a080b6844a90d1f0cfdc6b26da54cedc6856c24655219ab1e", + "772e7e78c1a820b6861425e6dc2c9c5074ca003513c9ca9faa93ca13d66ce21be09ea620c82d46b4f0596bbc5af31d6fdee5b6b0a3479e56e73905f9262f58a372d706ce7d864c012d4284a90b2ab02cb460c5b5ba221619376b4b5b60f6fb604847390e1c06e6200580853068fe1b782db16c8f449d2f94770a9b8d618a656ef7baa92a8d8a90b20143ef02897dea46a88dc00e409a485e7add068b4a5b2f524da8d44e742431d2c836b9972067d417aeb6ffc900483385a645c6e463218fee0d87d6a91aa74a5e8e9db0121393a225e4a2a7e8c672fde07ea76cf8c08e2ca02df832e784c35dfe2612b60cdc8ea9a11ef14578e86c21b76bf712503ad3bc68", + "95f0f3201140b089c0a44a9e46c6ae5393bc73cf9c0bbf948e3829e08be6a4d0b99c9c9743f188c59b38b7920135b9a2c9ec7a6970f8b95a6e131b085fc2914c036931cdafcbffc2acc1ce46d8b88f8d0eb23c7dfa48c2779a8f45934a81450470993c0fd63704f4e04f5e3c817db704308ba1c0b90f019021d332da8f9338a081ee0c87e8f61f74c4de2508a246b446ed6bfab29b53a4519f6b3344f50ad3c3f1b1c23af4b4778a7c8856172b2fbb1ae38720241fc7236dc8b70a0e5593f1b5da1b631f11cd2f5911b29b140e35c89126d4eb7e55a77b6be1f4dc64f45f237bf9e5b955cf74c20c67306088c3ae2a6d6ce1e7e135431262b8eb9508d74b4662", + "577984ace6feec162597a354b3c594b83058cfabae8789eb8546180862f24ce213a59be81634c202342139f1376a813e947f69e3d7e37803296f0391fa351d1cf384f0c4512490118a61bd727c4325e95b5551fc8619893258cdb102dc8dbc5dbba26820e3856eb2fee287429a8991b5e5677f75f68871ce3af789254d757ad2a24b660282030ae4e5fc10e40d3334ed787bdc480d21947f60e3b47db5f23661aeac8ca686a4388724821ad576260a483c19a3418c0b56a846602c98e1ce6d97b86239443267faf9fe854d3bd0112fcdd6129aa26f5a0341c505b63a6c3fc20a1ccc2082d8b1db2459d4ff044d0c7c5b393bd382fa171253f7d966e761c61bf4", + "88b08592f6b6077e685a537fccf00484d09929b04fd314600b76c453b4b181fa6bed6acdf260b31eec32cf8ee7541688c877e970fb533976adde9673fe6d872f1b9ed14c7c33ab1462891629eb7cf69c307d8f3099f11eaa5de0741a56a83c284fbfe7f19a156d70517c4ae5a096357cad43ce6a13f5c11a06948d7868afab7e7adeb03a61f8e4e442e797dc5a0f9866a5256f1228b84c14b129c4dff1ca398f0cd0a296de2cef79ce96cf59bf92b18a8fa1515b2ba2bed40b71160124150a10f2e59d1b4dd67f822140c26d972e742f27dfface525cd30ff6a11df2d06cf5a4be2520607a88149ada0fcc2f265718b3d9d8e10583764e43eb6c487ee82b8032", + "5cd61b2a43496b82708c22f3be651517460faa4fbd54cdf629b11b860397a6b8238995546fd510f23dc4b0cc6db41880a881e2f1772906fc695b304d1d4eb82f09ad3faaac09935831d574ab0992b7bc06ea42f993352d06317fefecca76ea4786eacac101ee9673bec138d6520e260a2214013339e36e310c6e755104245c75d352adb832af38e5a2ff8f5cb0df6d56cd7d424f1799fc6b4031f6911f0f7bd7a11d8fda8222b1276f4840d517ef331a89f59078a6d7b8b485cf80fe6b744e9be058855749480f0f740d68cc8eff8565e4353c3d030ff7682695f2efd8cc70d1f8e8d593447537041c09b76c18855ef4af6f81ac9301c8fb4b2306fe60bb7484", + "24f779e0a63b28606a1817e354caaab9476c956906f27da1c76d27cdc32bded42eb8d7bde6cf20e8a9319e8edddacdc64e913bd2929b8c724e4af99358b8aea343faffc2c7b4b35a351669e6d099bd6589a18cae6a40c396e0092cdb9b3d3e1350b0e2d316577ebbfa62832de9ed82abbd0aadf046f20fa9e4de3387b7b79e37e73e90f3835c1808c5cd8f7a52c97bcb2977cc291d9dae04e128756c175fab60067f99fe61244166ffa0ae17ad1554dc2765625639a5fcd3944b4c93a2affb904513dacd0ff0a4651a2f4e3b271e6831dd5d69cfc4a31d534357543476f323de0cf5f4dc41c000081094fca772bcfe645d6fcb463e3962e70ee72b1800def4ff", + "831bae645fd0701b3b1365aade2151ff6e4a80d91f8084f6923188c33f1d1f29225b21d458a5596830d2ea8501839eda249916ed70c881d04e2792fe95557324a673c23d98a13403ea0c8c8e425d289c5d66a38ca416d91d0bc6c9edab5fe92951ba5c3fe33452819354b0c475b8c5b38294de879ccd8a164b23e143b44e19e5b21367f56f1b9be425ee2daea7395136cf1c1cd43f0e5c48bf5c54cd70d8c14beb747a4867b9edceab7769af78f357d82e9fb6e28587fe1381d84797bfb6d9482e9c1ea957b7e786b22a31256fa9d3d899e72fd148795bcc412b9d5b027dfcd9a942ab35f49a33729aa7e513dc1019aff45aeae9f5b23d816a48808dcea722af", + "5bf17608afd8866c429bbfa5bf37e65cbe6690f1a872a7bb0c406ba6a7f37df745b6e617d2dff5dc22b618504edd64b1f81a7eddaafd8e5d825b2b5064d2b97588889d6fb1e255589539adb4ed9e186942a20e43f4b22a8412d8eaa8ba36c606390ddf4d37ece28e2d0b856471e63e516a3355e08a69bf3841f5e1ce9d7c6fe95a4bb890e4c0756ab41221b0fa1d99cf88e5dd72f935c7828bef80a26621ac975b3b484d6942c63773cd570587404b148ca455c8132297f395cd40a34efdeb39e047de5e46da895d0b4ccc008ecc82db1da48ba7c3cf4f77ed0d5de690adcece9e0063eb0562f295197c6dcc97cfb63637ae9a69003b95f66b2c47b9030c2e32", + "828396a036080e6503b3c0b8944285dd9f3a12c5ab2673d2b721f2ec31ed1669c5ae8f67fbca9a4100eb6b2e8a9c5c0018bae174aff3097158f82aeed8cbe2ff429d941b9db7436bb4db2b360a1031f2b4de7ac1d3f68ea96189489b37714cedf331f8703c3cf75a52ad67f4c4124df26e34608c4065506a53e77dfe04fc59807651566737e5e2d31ab556ca1cbfdaad8db847458a34aa75eca13c8fa4b9027610dcadc0639e6d47a8491a1e26a7b9360ad1ea2e5fd5e0013864a7fd267f425f761f31f7aa04316b30156835a6676e54c3ee948af9f3c2ba4f9228de0f14569026db18e276edff8453e1fa86c819dcecc80006b387c78209e6fc725a949564a4", + "7f50c49b5ddb9f7c531dacca12630496ad3b32972ef87510b540f21d2395dd4552a7fd86da079c574dfa8ade1e503b5274f35a36c7980cc685a61ce0624e904cd43bc123206c692bfc2dd989f35dfa3095dfc83304345f2931f66adacdee2c53e4e5fd8ad0c2616c4cf43aa62a47230a9c85c29bcb3f2314efe1c372f0180494cc5b9f0821e5b3ce57d96a8ea96132218ddb588dd945cb2f291ed8778e41d3f5bcadbda3388607c039bdd8eca4eb93071bde9e8e056246519709dab0182ba56bcd9bc78010a7a786907a742aec6f2906137d4f55a0fff9cd00301cd07d91d51558d1f7efa6c829d04aaf80047d2a78e97ca4bac074103dc01ad0178b103d0559", + "21bd7278035764d7416bc39d22ae44d36685a26476a88f7287884a39b3bcda6867fb334cfad4842a1b39b9cbeba7725e376b2129c729f266b1d4fafd9bcb66f35e1fdfb1108492e8c43db71905f616c18e56efc0fd739bf76720aa807e927793f0b2d7b3d2ea01301b6019f975a207c46102cde8a0ef6067f0ffd751df1020a555550907474775d0cf6a240c5c93c692a80191f3f5e2ea2dd614eb805a4d157037e3397ffe6d092827c3a2cab72c6510a722becad5572b0f4ca3be1fa852476c877103fbf2474aaf403668b4de00808b03d061092d8203c4007a4cdfc481ec04b152cf79254974ccae32a914023aaffd87315c62d7a3af798ef913cd9285c640", + "5c2d0ea99c632a4b4c8e5c1e9f772de9d8968760cdfcf85c37e21a19726d3138f90a2f7a1ec47a19e01a43c31a83773d2e0ff6c30418fafaa2e872d427b7223ef66f73513ccfcd927fda41490fa86b77cd954247d02f4f2311f90c7c9b5396cd27aff285e5ab6742a7df638aa67288eec68a2d36b973b4c6a98ac2894e742b79ede874fedc2bc83a1c9bcda34cb7ff9f4ff1af9ac90f82417848a14e04115e859d8b1676edfd7d529536097cd30d69b7a205b430e0fdcd3a147d99bd60a3e2042f71b301a6cb7f272e978ec132aa7e5e50be21645d288060e8824162db55322b489deade506522d5df8139f7f05ead74385119ed865fd9f94c02d5cfe57e3db8", + "74960ee316044bd0e12da5d7b9603dfccc45afffb265e0fa6f731c0734829bd8bd10f9fae1a51f015746022ab02fbea089319b67ee708805f2ebd82559a95727cd377952ff1c5699d8df36eaf698a612e74260f000f2dbde9462606fc32ee6277281eb19084560dc9bc7d69458c51fe4742e260f343e24a94575c7f93a1a72a8737f8e6d4ca67bc254fb1420d2d10a8ce657c090d19d4a0ac7d6bc4f212c1f5f1d816e95d71eb944853a41382ee13ad60dd019a13c77e1952fbf45ad1c8964e18557cb6c403783b02c94bb7c22dad06764ba9fe8c1bc35e494cf83d60c9aca917572f11d4a1dd02466e638d4ee7fc6f2804c52385a7cf302f9bf048c70cce808", + "859264a399150ed1a140598d805475b0718c8652fb14350fe793f7538bfee2d8f7b014bb317042d2bac641369fea38996b226835dc434b5e955e8649d74f5fbd7bcd4a0bfc14212a918a7ff75cbfbc565f1d824ac6200e8eac5186b8faadc85ae37a28a0f80772314821bf4b81bfa7773f043c960bc849408739c993afb31d76bddb981379fde9799a830a65a470487290100ea586e2ea16447ebe099e0f9f7ec3db0a2ab182a9b0afa75100435be5982dd27e8c72d289ef37a862d428714d86416ab51e4745d993a7595a38ee2b6abad7b526e5a2d1ef316d4e90de06776079d41d6a4a82f24079a7b003ac0463f46469f103e3cd379bbdd11c99fcb6462f9e", + "56255fdc822cfbdc51018f5b098cd4f1bd62d4a691bb9cb3dbf279ed7fc41a51977a63e6eb37fa88aab9db4cde433e02bbddce752cb0fc82357eaedb54f5ad4b1e28e40120648eeac27d5232a60b8ffc9e72e69b4d1de8cc6c1cd0b9b1e0ff462289602f73a230e55e1657a12947d5ea3bd069117500d13c075a2e14f5f5611f11f260c7dc2b7dd8057ce1ff5f73ec54d8fc0f7ad5c5fcb460e5529f95384b3c109b048b6b3b1e8da4c0d8794ab69d7fb04a3cf7105cad4f6dd04b4123c28fc382ffefb16d0b59aaeaa561240fec6cdcfa53f6fda9ad90f722476231550f7d7e0aaa69e4c9fae0285e1fe19bc431d9ce24f8fb28e8e72828dd454e9be2083373", + "80699c5236e484f15765105baf6de7db5e458f8105a756c7ab2a8476cda5a71332b699727de6965fadf6f005860dc0206439780826ad8adb5323c05f91b162cf7eead165826e26d552513b1fab01ac3304de7e2555c8f6a4e42ca08f90dd173b1f0238cfc9826c9d57203bd7dadbc288675aa8db2d9cd5e450f9af055bcb8f90469f9810c87c7cd531f613fc20bc2bb6fee3d38fea9d06de147a0a642bf3329902d687425d3c3b31cb7f3ede5d31d983bd39369ad143d3e7fa3b436242040a34f45913bc45295aac9d4800e391f73ebde1ef77a9ca9aba69ce3211ded109d0f77846017b5d9063b0f45e7151a0db26435bb7ee0e85baec604f5ce1ac61eb0a82", + "9173c92c8d8aed1334387c1aab9312bbfea3abdf3e739102c2282519d5d0ad6edaf797b205a5488c66588928b8ed5d67bd99a6e319847295471ac3f36aa357760422d8886507005eee9a6b72799e4ccdd776730c942032b86938c5a17146ef9cd93559e256d3426332e4331f9147c72d6d522b014573175cc725c13025b83a0996d09649548de5bc13589623226c6e6b159c14c43eda802a5c552a6699d77fb0891db76b8fbae0b30fdd554a86d822f7fea3b90a29cfb5dfd67464a65fffd44589568ae129a74d7abcd9b2465b3bc2a77257baf04f4dee10daf943755de12a5a4f3797db31dbaa4d1271e85bf7cc8a7816918ca8106fbfed18947b9bbf902e74", + "1bb23eeec3739ce7bc4035d8ec86d16da0cb781627942d02caddaaa4d4c064a5867a6f4642a6b5f4656838e38b362784d74811d9a45ec40d5dee5b719b682400ac28c60f5bbe190a7fb25ac9ed0b37e875c82b647d89838fcfc4d5aa78c47ae4cc12d4c212885b191060e662bcc4aff1f5aaaf69bba9b0cda9bc30855d32ed4587a44e1bf390360aa2ac921c595c83b7815e10c5ca3599a08931b601762d99b43c0b45ee19a1259fd8a1666a65e7facfeda3863d78f10d5003160084aeb06977142ed0fe80d0b1e49d2f67afbb0a7c384bffc982b6612634d0a323fd6d24f53835c64a30f2e51df10e64660c7cb4868c2c9d0873f81b1fd71bc1395bb338ee93", + "528a5ccb9b88bd7367ffa786b40384911a25128b55f416ddf850087697b916cb8890340d3d2d0be9a9ca26965dd85944c34e0a6cdbf0ca4ca15f905bfe7dfd763627f3aadc791e22cf31fc40f9db9b51e99b20a580e27353bad491e0d1d28d8ae4f78a1a7ddf7de396437573c5296fed0cde6985eca016c130a8f69f04b8aa1bde0bd95180bef8449852cda874a2a155fb92b00d189cc2ea0aa0973f73670e7dd9ee25052b3fd8a62678b81eee08b70fc06bb618d66bd949540fcbb96b65069c88bf27cc3ce20206c071e0736c6442948b49fc7ba53def1b0d057af6a766faf7604ab8e761fc7cd48f55f7d85299c5a215e69f2c70bccd5a2cd75ff6e44ae6f5", + "30b45f73e94728fa7761a41a4f598257461dba5fcc337c84a0de2df2373b602c5b680d406d314ba5885c13080c6f08fac4bc92bb4ea2100d7c70941a307e88e3a3623578d4656a8fcd0a5545db95554837083ad46d2a586502e0990055ff477f1883c0e0d2d212209848d96eb4910c644b2fe8ccfc3bd7cbd669c83d28b94c5a036fc3186e3aaa8d035dba72bbbf1a942ea868f1d28f0c46063a2db77b553fca6a18a5c8101f7373c4ddf7dc1bfaeb2513009ede37bc6310fe80f43976531975eebcb7d0aa861d9a1fbaa58423b84df98cd264f1f13a1f9e7d22b18b31c964e8460787d4f0df8f48ff4d52fdbf800b4c183ce39806d5c287564ee365caae37dc", + "84d6b8266762ad7b1501a06cbbcffa76bee73d20a52f59bda2da0a7b136b909366d6bcb6c73b846cafbfb320a467ae857a757ea5475234fd120fe8b50269d0c19c1af73dd8531ecb327d06cce89b6c7193a4fb0d4abbe78ff06ddef5b548c1828cc11a367a948f712103492bb3d0eccacb8b776422f315d1a08f51428b1769a494a6ed8740d197ff05c494086615c31fc250f3deeb60e4f8de417ac879616badbebcea523e5687052671ba1a66c0ef9f618e9ca3c73913b8dc98b97c826ddc524b0d143c011ae78203ee60a4026b5f3a6cb632b31f86ea6c865f8720e0cd8b66b804ad6df69fc5aa47ebe3f7ab79ca58dd15c237a80bc180742385640b5d8c6f", + "a0925ca3ac14060a517418354549fa17a007e35b2545e878eb0f614c809443da6124d25d3b568f30f3706b73043d7d86ad390717b89ae775ad44098133878a53f154a464df4baac7150d370721fcd1aa07cb15b5fbcf24999d4bca1b362966a4d92d23172bb41ca2cd2ef2f417937df8c4f04ca83045002aa6cd2124dcaf928033690810b4df987f52e277cc890bcfaa49a585a0568c00e995387e548748a2e97a4162ce40c0b4c2dba1af9d40f0b25bbfdb13ec5adbfc36f01099495e6897061bb738ab17aeedd35e4a42136aea269a2fee25d9058f2f3097d26fc6ca4e5256c5cae4f9e3eef66228eee17c289c57908c4e301d334ae7365d0d251dfd63dd45", + "272b2124ceacb53f600b19663eb70738ff9cd05f59701a3f5e8ca0e96df803c9d3ed1e357f31b3045ee930ab47518b4bb40ac9015de90e835dbd3def20c3e308297de35eb0d27b57aaa92978783c5028f8322db98363d03468f76c06786a5f2268a341c1e8a05b013a8702996f0ecb4fab45fb908588eaee9b2aa61e92a5e10c05ee2ede2f62ba2c9e8c40a6fe91a4ff7d2d9bb67d90c672971bdf9ab0f38517f55d717ed27f09cc136ab4c6cfafb5a400a9b5c4c9a271131d418a270c37d05a0f254a065d3ddaa36ced0562891a78117782ec5b510addd01b11d2982c47524f4c7e7f62578606141c08ba3253635c0cec2ceb6312bd4ddff69ba6f97a4b834a", + "4b266f822e3b3557538e33305db1e99a5f02b25d7c9abf9e8eabcd1ceb9da41073f3fb2e01debe61166d17c83d4687e3c1325576ecde3da008eaa7ab9b37146cb70349f3823f14785f42ef34d175c6677cf948218259a59596dd0244429c4ec2ecf691539e8ab09afc3107b63e50edc9220b38093f51acf421917b13ad7dfb7015182cf20d8e4c1d54da2d0b5359500ae97133a6ad1784fc79fc2c425d86945a7f0694e2283b69f3bf4c54f5c4055fd4f5fd83de4cbd53860a7adcd59bc6263892f3631bb9c8bcf685eb197e1c0e05f100bc6a78cb4dbd806c3ac6afdf9123312a8ae0c2dd078f98e6adec10b48b1c09e4fb0b2a55e16c02fe49282f249a2d5b", + "8a222d0a98c8954b6129dd86c4340dbe51140dda4fb45f20b85eb5237c84b32d357c05b8aa30aeae41d53c1741e503c888d37d628fa6d92a6a151198108723c95a3142535dc0a1f60c5a724e69eb148f7f2dbef7a00cd32bd887d9a0fe1691fcff72e35ea4cc404a3de8cadf905029ebf304113a583ce734d8908f993058534827f0e1ca31d9273ed243d03a031dc03c3acc337d2f0e45915f72a8de211b754f8b8ceb7435aba2d405b53ead8634c023f65e9f6c32c535a631a9ef8c5bff3a4bee69505becaad4121738baebd4fcfac37dcbe460e3fd5222db36f5010979543ee848f37fe28faec0ae3b9430df254e6b4eeb490469f855e59637c3ed63e5b05d", + "7615b80fd2daadce608ba44cba4d79278cdb891de329fad9f94cec7aaf26264afd4fad38ea8967a4d01fc425c1306cef3577add2de419fad154cd6fe255b2a0b83b2f996df1fc54ba44804d9e2298b7fc5f23137abddb3cb91575a1f51150a4531053eeada03bda86aefddcfa33f21f8cae382c514d781f2afb6f392d2041e82dcb94721504ee68434cdb55a2261ce51ec93027c0691094233c48b0da788190373b1221946383caf5d130709de287b226fe4ed6f3abe88b1e016f9f54a10644036fc5401cf7c2f9e5954e4d8748480d9f25cb6e685e37cec4d341373ad495d23f443fb4aa1a004da93c1497cb81208ae2125c96991bdae8fa427ff12c648c26c", + "22cfe1c5052e4d18b029ae6e4c24ca5288cde8169d1da495bcf0421f0bdbb33ca16d7dd94c6bdd393cef8714d081970c9a09eaded0aed481bb5dc33b71a4bbd40961d69eb148fde91e32d2ccba7260d5dc6f833074776f9d21c38b4546019d32c48ee9254b4b07893212973190ee95e7591d48ef56e4e1bc7d87f21882a685975d40d99eebbf6c814b4dc5fa57312501c33ff7abb3b686c5e5f7ddcd264da62314ebb74ff42bd7e123c44c0f14570f3c83dbc69740f530f1f35910eadf500b98b9ede8fab777d3fd367832361974087ad3c105391a85bc7c90b692919a57a8bf6f99163ca1f3acfcdeb021c047f74cff1ff8a50c7fcb15bfde3a92c0b03b4b68", + "685454d6a6cad6c7c4bc1aa4bb630f9f203267d45bf68f12333648caefcf0e8c26100d0742f2b2daeae26028a1963b3f2c4a44492b7954bf11227914d2589c7b222352d7daf870ef31c0f920e20be4d2baa0d6457413ada6b28f69bdbb4c7a2492963a575bf03ec7e7e4f8cae98d674cb868886a9ac54042c47018e19608e2419b7fd913bdcae1cebdd0efa9259183b000c070e22f9de366a3787d64e36206d53d492041ba702a688abc7f842531064d0066a129bddc2f438c46851abada7ee14a78240ba283be479c6eb9737795171e10a04efd9f9f3a4386e33ed3b1e3d0bf08f2abafcc3b6c843621246df13db2fc94c0239f9f342474ff7fdb45ff2cb156", + "92b7f07941964925d43e3689d70db8da390de3b2c8aced5c3a2f91509cfed7a9e1febae038e6c1e07fd7ab6f6a6703f9a2f7a026b02564348b1c8a808e434a1cf1db2dc4f0bdae8943116801ba505e26c900068d6c8ffa1ba8ebab459fb3b19fc433939aba9e50a3fe46b201a9237ac4c0fc17f43fbcbee31964004fefa34b022670493af91bbe27f08875ba01532d9815f6cdd75ad4c785a34b8e53843f98a2428190421056581f8458b1d0c278036270c84590beb05f252ff52eb27454140d333b20deedccb0fae1e4560f2c9088467c994b1a5ae8f5dfe5e150560be6ee5192930a5a91b38965451df15136d12a7a0260c030dcf9ec2b683c90a3e4220d36", + "735d661a86d0ad7d55aa977c7da9f41ebad483323896646a119a5afadaf238d3a3d804ad4d0baa503a8eaab768061ff2aea7634a9d5f2c8ac448e4ae68b8e3483610874f0cc4526131a7cc8ac94bdc02e00a5eabd743f61cb2473c52fc376ad087da79dc9478135ea85166bf6ec12c123217408437b8c331cb13c1f2763c08c87faa58ecb1aa644adeffd0948d642bf46db411fc28745ad1b479f70aafb9e22033cbead4a3543ab80f103b4927c88d573e7e94b6ecec3fdf146342e8e5201714cc5c7fdeb023eb0357f59033cf7585a1683bf982c0b757b755f78720aaffaafa4af241623201c477bbb23a1fc234b01ad20dc7f3a1126e872020c8e643ebcc4f", + "19b37378863e8e2a3b7b5c72d619ff933ba6ca94b1e82cc681ce9e71e458831ce14d537729e7042e6cbcf62c84bb9903115d0023ec6089008c151f0e3d69158b51b1324edd99f4ccba3a40864b128b55fc9948284b5a1f2120d60682f352284a0518c41b6a29a09180165d1b99bb72a673c5ce9b05d2c3d7b137b5905d1d3e3b771ca71d2515198a08ce2b9609f29f61f5ca44ea25cf532976ecc38e61ba8633e21bc1c111d3cc61c1fab4167a65f4bea5d2e89485bc743ac48d68cfc79521488e0c00bf69bd72eba99093d6f1cafb21c8528ca4ae47b579f346cc37914d6f7c051202e9fb312c728133b190f32221054979d157577216f5ac2f2d99fd74a8a", + "7937a399c93062bf7e8ea3402441189fd04feeb2788df0f0d3133b2e79261e9de8e098416f5ead7069c6c22150a275b36df45d95d17a23d1ce1af2b1d3f963682e377d5f50018f0a4ba1ebb059a5da9903fb27e19191ea3009e2378340fc427f028d74fea010ed136dd5710831af92b3838562fb480b29b32718ba31ce013ae80a5f7955154520d74d270a972cf6bb29f847391b249b44021580e128e7b146f2d78a87a855a1d7511f01b5efc7b79bdbae621d6e2e120363a2ba41d41b1d31ea6d599a64c5f60edea6c454daf34cc0df56dff6325c595b0fb82d4d5c525f12555dcf0e515e5d636cc8a787695c6ef7517940ec2e22fd1747aefc7c6be1b8cf5a", + "5e33d2152f7322f870bc838c6987ace5128c64a5389197bad892fcaafb2e9d62f3dcdab85338cdbd0c1af83c2348ef91d0db05c53eb6d45e015a7e4ddb5dc8d4d3f3f1212afbad8e964f8bb53ee4d7f6cac871e3dc740c6a6966d5ee92933afe9cb0a6f21fe46780f9f6d00ee13f36349b7eebca84705b2d82e4d389d1207c065f178f908e23c299fb2928b20bf49ddb61af563a9b86ac10101c46a2d49247f819ce0627f263d5c5d61a77bb6c185423f6ef8c7da6d3c98f40007054718768ee2785d124545911654214aeea16b1680ae4e91f4436cd3cf85b3703585f6dd24d261b4a6d53d6ed7eca15cee1f305e937011f2acabed930c8395f8790586f4424", + "492fd0ab61d60d43793a05068dd3ed2d64d822fda4a408cdfb63913527e4866288bd94852b19cd0105f9ec8b769e61f2b4dc85e55991e88620b076654ec898f5651b86aa907dac6a01435d6155d21627972d487bf8c4756441dcdf0b924ba95c0399ff45af976d3208a538f28ee732816485e0a11e5fd3b9a36a6d1f25518048b130ebc4294a3e80dcb474cf3fcbb6c372886b35524c6a63585c40639da24928eb2db3dfca312ac4fd177654909e458dc0e7a33f3087de5f02b01dfa2babe7e209111ac7caf476ae6ce6eec7f0ec8a8d261f1b9be37b8fb33662ea020bfce889cd89d51b615264381d48eda4b276d8f65f5b59a89cdd139cf52316f57135fe28", + "7b3a9a9386463d138a0c9d81255d584cc5ce34700be156805bd8fd3a1995c34dbcba82e7273c44ce9177a7782dc81842e50de9d53d352c64aa22d598ae3515c86004ba66e2fb9fcfb40d2a474ae9080f847b44d75561ef7da4f9008789746aedbaca05c4395e3745991e40656f15dc75363f60bda577bb670ff9b322b84fe6dab267cb916861867e35d899b0f5852ff9b4b5c4c8c636b08d2b6faa9022d75bbd3d357c48b620c46f8fc32c6236de8b58abf63787ba9f7a40f7c5fe511ef42396cf4939c963bcd52264ab085c430946e0ba7dea6ff7f023d0c4c537cbd5d355f05f37f7dc924408098b184a8f8afdea0c11d5776b3ccb0952349e046847a215c", + "2423df810737ed04c2c05c2f49be3b05b07bb7d122b5a50d96ae2a908bf026f12235a9c48ae5196739bf5a5a0f2017038eebf7bafbf07c7298b009762bd3daed8bf2b640bb2bd4bc2d00090b35863b95a39020d4b8ce4e4b4fbc34f3f1343e30801e6b2b3488b5e5352f0bb87150aa6b14bf76b759ef48e8acdf231b4f2a60f466573589434503ccb15f43740cbfea1d2d37d4ac359dcfa405604476963c685c534792de48fc0d114de028a8b356b6c54b2a88832f9cba2424470e88ba9fb3ee61c039cf5daba186593214d3bebf292efccf251d68725b905d150a42699f60dc70632a7f9b8d89f1ffd8ff1610b10552d89dbe620fa77f77bc2c1da4853167bb", + "6bb883a99de7a9d732fbc71ba19aaeb7521816c712b11e4e43af4ad2f201fd38e804f227fb9c193def3eb8d8a9a16c34f3b104f2d94fddf0c1ee3b3fb297f396184dd5ecd1116f7ab042d813312f45a232f40b74dfad2f15c41d6be7e73bf02b2ea94f8c0235042be41a0dbad396a5c217b168337ebefb27ab2abc046047d70767b164b489c87c30ae7ea41fad5e2e8af97a396365c09f1ceabc1291d61f95794023b34a69ec92968943b740a7b62fdf29b0de6db2139e304b407beae8c91fc9d92c4030c6151df8d6005e09af647ec79ee96cdf2d89524cd40be2fdb4484ccf0fab4e82341d6113d68ec0aefe3c08a8fd4736a749041448eb40d45cd794f1ca", + "9cba63661788a15d3cbf51a40e52e2687144ec82e83127a0e6c1c3cc44445a2fbd5401c21527d8b4e2a219b24acdd15b9df5b337b1eb0928477fb7f58f7a23f2c3076f8f96614cbfd9d03126b503cf03bf689b5f39094da54f9c9ba44b07f22af95b8f1485ba70af4b51fea61f45956921b982f66a0efa8b06657785b4fad81d98bcb882ee9543de4efec5274413c2992f663a40ab628883b4cfc9697599e1d098c96b106caef9848797fafa15d246e9d2435d204dc8d357d773cb1f68f0e78b4fc4beacf069e17dd04372a57112fa8f59616ff8fcbfb3e0f0355ec7aaede199fd0e93c38f32a85ff4473ca047ade2e265ebe07c5e0b711130985f22cbb04d36", + "7e034766252cc2a18573275acc096e8cacf6864c96bfaf86bc9dd2f9039266438a9a43530646380c59b26c67f01a6cc9331e4471c328fde16d4bdd785e2b5d0e73aba916145d851f25651f8aebec14c8ee818d264b6fb4fb45bcf42c052a6920a4ec86de2fe1a0b2bbd34f1af4dfda3bbd5a4b2f727e9f86e4cb5c0fd137433504a97bc9abd28568f413f557f368e48a9cf0e2cd75bea2259a9fea103fe920fdf7dc34ea04cbda4920a398d17188d883d0cba0c06e8548bc92495a1e131e44f6d2b3f2175c3ef80885528e7579495ada7441129015ad58c56ee8721b22026a331d801acbd0cc72838cadfb5075c6c9afbfabec6a58bd4158ad063af83e69f118" + ], + "z": [ + "7b096a87d2f8fc485175ad5719f7746c44ed1d677b287a4c71d84d093c27e1731cbd6037050afdb20117c1a38aefbdb70d994d5964cdf1ec352d2b78b9f0b32aa5645fbed91cd96eba92a1c1451cc518e04e676a87ff228bbeedfd0e4eb6d301e5db2997cb9ac41680861930cf1977b242762ca7276fad3ef3a87e724a65bd9f04ee7303d7461f946756a8b5fea8e6d1ba49335722f17b2f071b1ee5439ab1a8e7a6a01bb8856251672765b6049f113e79bce3c9d099986e326f026ce97815f3833869223a0a655810900a55f35057626f2beacde4f4be52aa466909c1a91ff978c3ed5193592d0ba8954ea9271901f4450626f48d944cc656d75bb248cdeb4f", + "951c493c84761405ffb36b92b3c6e622480b86dd666070e99e4b681830b4c67b793c5b0d43154de4c048c8a6d8c2a18ae98b8ce1daf6b04d9e903a10fa6dd1664f98a569ff2c8ee7c445fca8f71fd5f836440d290bcfb1551d6ea8e8353deaee06e2f80d30aa0953192ac4f9fba1a7cca6c1023341504452b8cac69c8429ee18f2788a828f827649795bb9f00795af0dff8228f5f3b271617c56abeada8a266faf718afc4312a0034ae7d15cb96c5b9b9059b243a95eed6e1491441d5fdc41400e7fcf9c462dd0cb0d9233ebc4a927f1fb59536bd7c21b569c12e3baa249216102f5c18b5c13526ddb88529ee0b0df7ab54406a5d5b7ee95f799de2f842770a", + "268a869b40cef0c339a39df9a903962e66c1719fe172c25e33d16068d35fd32dcbafd8c680dd2b8e1cc8a98916d692823dcb9cdeda7133a33017f8e3546bc1095285c97579e3cf87fabc6230cdd70f7ffcdb5e0b24bc72c3ae5c0d53c7c38baa4ee8276b90d402b79042a20372c9ee02c811d0a709134264ff0b34b64986d21a06cee299525b3516857d2f6e3f4ff0b253264e4f16cad06f401ebd1b6eca62734ce7ce21df23278e03a34c55401c6b5449c64c2da3e55802613dbea2dd4a02de6e40610357d9e5d1919cc0b2109c45b6132fcb1f8a3ffe88060cfb905b395a85dc4d6d10addeba74cc63975031e5ea2fad96f00429b211bbb29ffeaf0df596e6", + "72712e7a3543a5fab4fe3498f123f74eb816d9ad6908f1b71e82da4a350011d23222aa6d9f2d06f391cadcc235159e0a5c682bc7dac21d1418455938d989b8ab7a0bc522bf0958b944740b161d8c5923c2538cbf7b7c5edb247d1a716c6d6496e70fed21ca53b78cea24aea70413c4f95c8679713ccd2750c284b8068f471151dffa38e1ad678ea45ae5c38bbd9ba143f3b9b5fe9f19fd64f4d3c43a0f6baa230b776092bc475bb6fa04bbeeb10421a294f831e03205b84688f42433e1526f8b5f66866ca431cb76fab4b228b2537307ac454016786347f0e82fde21e7444be053cbbcff369059df9c4330b907fd93877cffc9fa991be1c0ba5a2cfc8e97cb35", + "5352dd90d71d14fec500769aab74ba45371571f3996dca36db969011e1bd617c5f2905a2355308f9c6196824eb0751946980b9ba8202639d07a38a77cf0f2714de816463f1f0b7bbc4013ee92a839b39ffbf8cfdaae4200bb9ddf53c216b7c94a0c762969f259e7e22e4c6a3445c7615a9fdd8168b7bd7e2d3323cf26da5619346b11021bef5fd93239c8fedc1c0d00645d10a0960e61b8cad018b74cbc4f2ff8201ee071b1a2e77d9ee1c5705516b7ac62b0475fdb14a79b5551aeb4e81a1767bb9607800f9b26117c4f1c12cac20b0426e0071a4ecf35ec1c9f81ce0a4aaa662194c766d062521bedaaf0ee381ce60224f0ca771b151e962e23447a08e3e00", + "1937d2456e97bdbd2ad30f7fae272ee17a8b1e589d0fece30f9d6f9ff5942142a6a441a739230964a24b435db892a0bc932d37e8f24a9f2342868083d65d38e76382c3cc0ee5ab437ee47e8b7bb6a613a67f76691af9ee76eb5204cd2816ff00035d10fb99017499576c9bac4360be61abd11a3c1f8953f2de5cfb3db0b7ec63477a4558a5b302c2b766181e858d34013b5dfa185a49184d4b99afe3331b09df2b95141d04003f91d5f9f8b80fe55f048e976079e7cf6fc69addf96a7d3f94042a64fa5bf653513d4ec128ff771d4684681c78473afb3ccd57cea947f5e0c24604ba20b2fd43cb346ca95eddbf4ea77f2fa2602b895570a02cb7d1e6c7afdd2e", + "666d9be052867b0d97f20dd6e03d238adcb87c46a8331e6ddedf0dd311dac883391649f6e84aa6fcb0ba0b8817276428d8b549628717d0c5be7d4e073be7eee512221e60ded54f25713e5692a877481f3d3fd243ecf8d7e2fcda8105cfbb46201bb4e1be16ec5b6e9a8cf72731f3c04a9edb050e4461bd0e1085256103d8caf88a680c3fe77e570feaff1fe5152f9be3df0158ce351898b77d96b708ce77f3d7923989ba8f61900ad5933b3c3963d2feaf0dbc3eb54d1e36344e4a411aaca9083c45305af7b5bfbe5d16f906bdb47af071ebc8a6430bb98cc619ff1bec34cdc982fa829087cbb6ee4aceea46b346272c4240c7fbd660d4fdfa79bedf674dc4b5", + "48fb7208811bb70dc9ed1888dcc4e0a16b4e2d740eeff36046cd8de4a7a5d5ebc3807565848b39d6dadaddf09f91ab2dbd9213b59f80099e511c02287f1d1e3cf704695c812b52b006e8d559ea6431f2fcb29387e6671b6e84b4dd90b4c0376f62aa2f143f43078f08a04e359201f0eaa38874c6e65c9a0cba157a8eea4f761428d87976ce1db784c945e48edfd14d33db38f94621394fefa46da6bfbecd29bae76643e302531bf36bd76231cdc77734067ebf0db9a0934fd4bae4685499f4d8ffdb22d394cd0d833a20e7a48c47e923b63b883945829722051e1113415f2f9b81e50620abd8f79abb20ee54890faf9ea0dcd07e70d55e863dffe6a4c7b7ce22", + "4402929810d8ce24582bd8d1b55358c7a3b484a0c18841b76183d867e3366e80c803acb4dc105ab5e5515406ba4c0fb6b107b6056ecda4d8d7146ca9ffa9c175a69e84e20ba9018b5da3ef5bf2971ef1240deb331dae138bfa9ffc6d3948e3c370bf78acb59abee3a48e90a2f91954e80f65811e0a48898a158f6184070e223c88239118ddf93c507ed4c67d33014f20f2147c2ce89a191ad576af527af206becf0fa204a5933082d9d65edc06e371d1e91215fbffcb6d53a0302db46e551f5a9a2f6c9bba01d46efe4164a5580f1c7704a9ea3891d438fc0198c3538052d6cd2f823314150b18b3c564e05090bd40400a34d6f4dee69e964496b95d1ac29456", + "277a835927de593681f71c28a96b9daa5d8fc313e87f65f348369a2b8621650d7b6c1664a0f451cb7e902890d34428846c1cc2b6ba093a163904b570f1e93141d783cef4c1d26504a3532ceb3827481f8591c45ba01e7e849651e0478019b7d9635b9a1293a7e98a33401deddcf07545961899c0a7c14c79aada03318ad5c24f7b9a20ed8b8409eaf6d55c587620d06f3fcad971393234de253f964cf09af13e479466e67bd4f2d8e1df02c3c85293bdaa09d09e9beafdf5af5c3d6be5ffc4aab10c0a45ecd36182dcfc6a3869827aa05a90f4dcae8b6d7e32b7af1c3bfc43d6312d5f5019e5afe06b398c66f42a15bc8222f7de094a4e6a18dcfd2189026585", + "2badf34de98ed216fae7822411999526cb314ac2771e9f3cf37c0ab4db85d685e22b0b3ef38fdab0d3f7e949568acc09eb5d58cf5f548dd9e7f013b609b7e3e51ecd58af99749e12c89d2f52d82bbbb2f609b807da346a1dcc4f30e56033e70f084a5d1bd854586cb93e26525f27427e012b99f4c2b708944d06a5a848503ba74579926c209fcfcb28bd28019581cb5c8e1b41543ab2476698e4531c64761cc611f1676b3a4a5845e2d1ae216332d3df99a196c5911a15e8aa2941290aaa8274c649ed5ab292ea971afbd506157ae336077599e0dddd0dcd27a9bfcbb529d92fda5545b490bdf751f7d346bcf6b2b23ca4a1d6bf091033f81aa347054f1914c1", + "922def4108c85daa00cf29cf225c7b51ca40d9545c9c25c6d915c92a682d5678efaa6d1b8653f59a2c105d658fbab7818714d7fba9096fc2c8863536715246e0b338bd97d0447e892f1d38dfc3527b00d95f4e1f5524efe9d110e4788e1ff0dbc8cb2b6abe4b819822ea46fc66ae8b9da8c607120b10f171f3914daffa24b92e04de0a10e4f7c17ea3dd35dbfbaef2dc13cfeb9c5562bcb3c85e3c9235021912e39548e36ff6cd784c8d4b18272619a80b41aa7af032086e6c305b8c2ef90c02e78ec917bd5519234f9d5c2d1a137b02447bdce577e0e407a6d9d3e3976df69fad8cca8e97989cca2ab982e5b62d37bd5aeff2812da3a7fb48dabd1902f4a9d6", + "a444c5d80d15d4bf62b96718ea9867aade2992aed6453d332a45296f014fc0dd51415f6c9053143aed1861c2a7590f0482aa0dbb905529b133272c7e0fcbe328e36b5510ecff48a871eda9c50154c997673a87d1663984f08e09c05ea8849dc84b9a2630646e4c4f80b2232fdcbc6d0bfe9a94172541bdcdd329fb33a841d6974b58b28f6cdc313cca0e8a32b05fc096bb1c83d0684bf22d90071ca3abbaa135c8b2a3ad69c0d152b0b933d7ef096d33b7f6d63debdd3d609e4ddf22118d28c496cdfd74923dd991a4c9b44a28609951122e7c8c768878c9c079d1df362f6eb9d678ae4dc457dfde78ce4f281ef4a17e975b294f54ac496767b72e07b9be1844", + "727de2f7d41f93f793ee33baa5a7c4aa19f550a9bd9f8e96494415028b5da8b484bf4cadfa8ed8bbbb613b3e5b4d8a11c25e21cb16f2ba5ef9f2d69f3fc335eb0a099eab6524775252f326b306b2325329b694984085eb1cdbb2e1e01b81d52a8c08b0f3988b7f042606ea9aec6fa40682dff6cf98c7cf71b9224b418158b5252551cdde497277c2582a3ed80488b6dd108a0e5c5417964dce93a40047025ac980aacb8d2c1e717f3d3ce94d8296ca3a9352da33b37edd19ed413807dcd004f7582bb99ac53db34727f803e409baeda72e3f6e38be42c60cbcebbb79b51d8bef25117e0be7ca31f83dd04f3d0aaebd97fac1a34d7d78ea6cc6ad731732e9461a", + "3c7e01efe3954445bb26a35fff8e711b5bd46c0152de0f6336f0b223c6d5d6d5795ee6bfd02f764928b7174edd2600d6e0d1d65f19873fe0f5c990d7a748c6159fa24f542ad74460eb2268de27023221bb592171224286f20a36157d1ffe4855897c95b7aea3907d1318ea701453ffb96383c31266d96dd983288d1277e3ecdf799dea90f226619544ad0ed28e6c8e2374d5d8f5a78d20739fc57b41c125b34ed4740ffc96d3469f37f4bfced6a1d5eed48335f6fbd4ea943ddf72b07293551d654ff536fd08d671af8d9940867226a21bfa02df93aade42460ac3084342c25c26e8914c9b2a00f61286034e11ed6c0923533cee2e8b20ed6760388f89697023", + "433f0a36ef55a278f4f1a968031f01cfb6c4e903104f983fc50142bc414410c8abf8ad903fb22576a7558d90e339c5204392073296f01ccbe8f3351f616cf5713e20a5331efa258ff9ec434c134bfaafcc2f48214711d13f0cf5bd3c09d99d2b1cccd54ad5bbd05332c6aee189f4057fb65acf824c3cfaa73c57a41584b20fc568dadbf5b85add3e837f81ec50928c5c273c609a78e31bb53d6f7275f965afdba46ad037c2c587d43451a577b1e412218e5f12704e223945bd7a98411972d2f053bb0d82622e125228827c494f6b9579be833bb01114226d026e2a7eca348e1c026b8aaa0bb5b802a4a77f4afb00c11ba4aee6ebb40748173efacc4a63269928", + "1602daa5fa0121793f3af0837a6108026c0dccb84119e40239f04937e14f07b0b59e1aeb5f4280d34c2680a1f414c76627083c120ec240ffab782afd1d7eaffa46035cfefea763392e80dc17b7c5cd5ec747c805eda9ea1fcb8ce9e774a8277a46a66b627f13bb57d22d9020406d485d1badd0da134e86880a8317eb03e6b2ab1e0cbf18d83b425324a95af1de9f5284345e5ed6478f20335835321643889fa0f9ebf25983483fb6f20a99bdf7f592996609fde59467d3aed03d2edd85f2af073e3abafc70943a38b5664a9140940659a01f6367cdd4add3d0c63e959ff95f88779facb40cdc9d2db7ddd327e20a50f082229e563d847053911f8556b5de7b6a", + "20b2e01f4e2b39c6058fcbd2d84fa7b007a227602f64937b660fc87e62742c0c2f0f19e21bb23d43e010e5ba4b60f9d8c72564adc3de95c3db8e85110df5dd5ff0049c73ab6785b8c27b57c7e03edb55dd09b178d1a879932609abd754a173c42b31e0489e91b731dd441ac1ebc6bf43bb495447c011b98f833147c674555db18914b26497fbee1bd108873cac2534eb05a19143d06601b43882a00e0ad8dbe2b727350430b26ad39f531ccccaac14f638873903774a89a0d070481755fc529199b2f68030203d39358f70e6f3e974573840a0851bb1cc9d1c6f155e99a526dee372e5f08748ce2e49a83fce5928f89fe321672aa3bc3bec453ce3ec683ce99a", + "329e76db6177898b2104f401041d11d28a58f4f81b95810b45626f09695922d1725d4232147094d0b84ddca6d32fee121fdd8b1609d2fdc3e3930f97bba8fc12aa57eb48a8a1daef93fc9a4c4d7f326d4edb446254f2724d83858e932811c5fc151deb1e2c7813e95bcdb938cc996c840917908050606066259a44113e8fdeb8563ea384a2044f862ac934ba5f430fc65749105dcf9ff359596a22e512986061c22af52a2a186c073995d81da2183b3f7f9c37fd929a451cee21756a263eb83f6938db24353c067be42ecf00af57b1fa3bff3e2271173273c8a269fa9cc9c4097a365773db38463a5712869cc7777db25cece1fd220e7cc9b16b893b16f9522f", + "a4bac2955ec415198c90a92f2ad3570374b0553fe07287dd5fdc42398a50a8a4891a306304048d3d926ca7a3074ac1b20c66f8e9e0e5b3eae2c554c4cef74a16c9eb95b04f9494d05d6997eff9edd3312eb07db91e4bb848a880cdb8e1f289bb153de4eabda13e02e47aedf1dc4909278a62c583d033b353425ce1e8d6e6e3e59d336eb7ad300e5666c1a8fe65ad5def9f3fa3e90a09a5c519ebb8e239d784e5828a1cd1baec8b458bbb57afc1c29f8d48b52cf57c64236e3af0c21c283f71df3c5fe9ead00ef51c19c41e47e7566aa7fea5639b9954ed1eba405b453b681ac479484ee971c6825703bdcad70154e825ced685ad9da72026109ed62d15d3ce", + "a39da1381c74dc3be448540eb11f7b8459ba4f8018d5e240403f82dc25382d9d55c13c46e7c2e19e55a0e0663d9eed0159e920dad37b7e036461f5b9a9f3abf09f4bdbfdfc314f66ffaafb2fe15c7b69242e8ba9625d153214a8f4289189e5586dacbea034832e836d00bdb13a975525027e2d846998c472a7a18bcafa8194079959d4f942011d25f6912b6f7ce349accfc2ae5b00655b9f3dc1e2da7fe6a65adb5b269bd530e81dc94325a06944733e2d834a64492f4130b805f95582d9c112e5528b55afbad85e6d97c458aebe314e1b5d70233d3cfbf345ebf0c2f5fce788237323ba3ab4aa3922954a739503e157cedb3d52cfd0d8d94ed2fed82db59754", + "4827f2d9ac7e1636e62d13d9e2bdd9f3bb683055fe5b4884ecfdcb155387989289b814c10aebe4f0a537d5eded377333b83af12709cc7b5c44d58eb89303bbc9f13c75a2bda7af8fcfeb8d78932e44e3283aa3d7f10e6aea8e53bca275ed781bbb0c0d3f07c5c745cf055d1761548f8018621211d4d02ea0360eef04ac223e8804c61f7a00a24b7af6b0eba448645a83f60644a6ecc9966acfa251b43e75b0b1b5340335da4ad6be3b957b9e59eec05b9da03680410b7353c2345b78b255c1fa99b40c72e53d6bc8fbf62d0f86a6519495d5a960e1c187a4483efb087faa598cb1ac37f1dc562dca526d9739cbdffb51f8080df4bd098fd3d867bd26b95a368e", + "638cf722a7b52c5d732c84201d815a60c1c0c71c38215b3dad9ced380c1493a4da30d4ea009dd00a19742dec6e0c8056b69ada37389ae1540bc7a2fc28c07718b5be2384fac7ff001f4a38f269b2eb869d8d5d7b7343849a4351c489358000d006fb2c378d680eee3e367ebf02ea81444014d33ce16ef1beda4ad34fb95dcaeb0791055e703fb49ef94826db3cb03d231c284b5287bb4f6b01dedb044bec16b04049d382b96063db6fe2b6cf9848a94d2038a0f4a13343ecb405f8f7baf87e449dfd0b4988878ebecf89a745c387f0202aee2c93dcd77b68004c6aaed9cf921cdd95e60e0de3f94a2b7f609182d79183645a825e61b3be3e81d7dfd4202f28a4", + "71324be730f8b029b7128f5226367a950ff526b585fac8e1d6b6820ce64e9cb6413710cc3ae1c89e9b3816d7cb0f726ca9ea3d8bbf83dda3c8d2a40cbe49a68b475986ea1841a66d31972a218f57d4c0b1206fb701aefb86de705184b5e718bd0eefa355d42825ef02346c56dbb923126c4542898bb091dfac1fb23ef7b8bac4c8c582e7bf54f893b83c515cc25dabb48b99ce59523301679b6cc2a7f849d7e8732603089ad2729c849ed570abb5b5cf303488bb91acecb270269bb15c18391613dee826138634b7c403644f04127cb3d5440cad6470f8f0e606a87521ce6e3ededefe0001660f3c3f2ba9909b183f474feb562024a154429f7f0faee71393b6", + "6b3ca2bcd8ad8583a2d7f7ee21f75b284a0b8de55fa6d935249285e25bcace20079756cab802b98e3b63a68c8d0559945ac3b8ea8cd3ef38a10ab21634bd99d627032572739ecc6dd8abbd55cce121b482e9e33a374007707232974f8fd62e1d0adb45243ff023f01fdd887a4411bd48d15f8e85b2df406eb7eccd11cd97c679542e191b7b8a12dfcdef12203326615187eeffd955fe424dcecbaccffd816deac3a99a20bd9ada3ed48b296b9abd6a3fe241d709499729163eda2f99eb7793e58c33bc9f9efef263805386cf0edae0a77c5ec850059d7b807fe336f6f09c447ea62be098539ecf758f41b0e15638491a494ab4267d9bb608ddb630db2e220b9e", + "ae726ca556da62b6a121962c65613ecb47bae786f4bdd1285dba7b40064fd14b7f1f613d73d1c27955e5dd51b15888ae1cb828892ffa2d0d6faff5c42d53af56a390da4cad2c2fce939e55e64ae9769fbc27f3acae1a32aefe873268c48e3c95bb9fca17896f9721fb6ebeabbb7a54d2ee3449efe03167af9193afd0992e84e8a4e5f5c4da744da4f5950d405cfe41e46955907cd5041681751e1bc9760ac334ac2c03204a89eef0a8fc6547794bd9a08a90c69ffdec3e6c48313238d811ce80c4e9df36d8706c18897f29d60e73b8941b79a6da89abd4f9ca54f067e61de1cab39896f47ce722573fb36b3168fa5bd33e0eb4a158f59259f6ab0c4824c4aa4", + "4b53a292db7ff55c1d0fe2e083ccd742fe702d26564e3bca67a9ab834529e0759387ce6bb002163cbadb0eae652dacef02392b6c759521dd80eb21afe553f3b66dd5694da7bc59c4d42a8be8f4be6e82a830b5b74671d88952b22c8e02c13bedea5194bfcdebde83e44ae75bc8ee975de9b67c6bde426dc36841131a8c910ffc03a50e4db0b347f44499ec70ee98afa932d2472fa068c904d20ec38c7b7c7483270c244e7c57f0a712810f547f9d1f33e4131f4143f25ae0a63111939e6fa66d9650e7e64b43e2069c4034fd4c7bc50a780693cc7ba9153b323339e816ae4d54b9b03885267570d3867ec94aed5df74940efa775edf4b6fd981b6fe2c15ba1b3", + "98e617d7a22cba757d2d57edfd3d08991736d7cc5efa6dd25a0ae45c9ff28ca41f269d214401994801f0f75d8d3f766ad4f0194dd98cb338b5057587856b104b0f6c5904f0c766de4a827d52fa56965a79b707bcb9d7f9b44e827b85e05834d4ddcd0ba2746d7d03603bc775e93ac643d895583473ae199be9ddcf44427307baf7f98491703d711f6ded2fafef5d4538143601a1c2e676e040e777087e8ba73d34734b18864e1287f677e9ad09aa3a7390c433349c60e765eec23a4f7352664ba5b0e02f8ce1e3c2cdc1c43215eb12d5c5422ba87f5bff2160a01c907b0585abc59a034b68bfaf9911cc5645fde99158763b92e386515f3887ee86b9169d7bff", + "5823964e915e5c95e4c5fbc180fd6c695d9ec7348746f2999e942fd69b051d7bf68ec86384313f2e81deb4e9bcf3f79b7ef852d2eeba61de83ae045ea19b1a913ffbb828e0ee2dbd9ac0ebdebc8fbe3b6671176601d70815dad8b1e2e8c800176a1462a54e6b199e81119f509c0b94eb3c209a04f2945da57ca1cf1fc4fddaa79b1ba5985598d176f4d7b9a6766a49ad212ec98f16b943b185a14c5e514be4cac3417ed410752b06fe57ed03499622bcdcd0a8d2b805928135f5b75c2a652347f4abf6731657adcca6e9a401754bfb984b0ae96cef1a24e5a98fed097295517822124a161f1b051d35d8679a71112091fa6318d02be100325564501e65fac", + "4d2f84120ab7bc599218f2c6b6d6d427a004844fcdc680f1221c9ef49bfe32ff741f713b97e279c5eab6d14034804a73608f3c44d89e6856081114ce0f9585afc41e937ad6fa4c715c10e0138db6d3d065bbeaa520945636be9430eac8c078cb9d9e1c12dc3fefbfdbbc4e72ada35c2da4f62ff28b9d469cd569e551364811819ee5c4e060d48e45195ab32d607c89297adcaff286191d7ad1c500d1b9d6ef67a02e7f0969edbc91a3f7d83c0f4f649f7f9a95b3e673c09a124f935d2e0ee03f364dc3cb0f71ce07809ae43008784968fcde5091b975caaf269181863ed2a16581a224a9808f1e67240a4d575724fb57ef773e2931793d7ddee60751adf7b4d0", + "73466255075e0a4fa59b600904b8318b14d85577592a84f5db5f8dd146d260d9898a6221ad9917f577c69596da233cea64d47c37c328c34f217919f5d08180dbf989684688641fb73bbb57d15969dcde3d1f99312784f1b3a1965b8a4cdfae8845f26dd39281b179f1f68acdcffb8155d7772f40ac29b35428f1948b0649347c5a6a523ab8fe7b8e75eaf439c3ed38d3f82c4538525b326a09a2db10c55073692830f43a589fd7232bad1f6dbd0a02b3e1cc0ad1de93eae570272be497e482794b1d11a4e5870a81161ccda9b714aa2013d4d4e25a1a1a4649482c539be5023820c714b4692191924ce4dc6ffa45339c5a42a983bac663ab38861240f709cc6e", + "a8fd113bb4c0e6e9439a939d29e845d7ad6c387e6d0aaa9408ec787818a8cd0e403b5931f5d91faf77501326996219417f722abfff2621d4eb7ef79eb662ae0bb00d28c42e22e1ca3083805a2f0938508c48322ea7f86cdb7538b123cc35e5c788344315cf7ded91ce2196817dcbbe1476256da99eeda3d18700afcc7cbca0c7c29319737a90857f7bf1d9056fa6b80f8c64f1cee503ad667b852c196bb25a39e46cb684471cc453be7338388b42f791618e7c0b771305efae230f2c70c2f40926eb0ad4053dde718103bfe2e621bbb3b8b0e28aeb683deaa2a1e1b1ecf623756cb81542178401f657b367dba3e98c8f0cc3d5aeed57187828deac6a6ced4125", + "184623966e776a60877e1a3120dd72963fb523286b199d2a142a30ae4dd91fb01d943fe1b8024e5b5f6f7bbe8fb11059b7ab1c9da692a189b0743de9d3796396a7c658adf407fa3ac02bbf12288b8883b11d796cbaccba0734af08f1a51d81bc9f11bba4f839c73ca6db24dd6a6e07bc176fe2d8a37dbe2705bae3160f5917eb01fa564899f72873e356e9c81f6502a2afc22630dc16da248df8ff8612580448b7d1774ff4835ba4c6e2d0eb6bc2a8b2ed9fd1b7922b7f7f608c85cb6ecc76e44583a9f505092b66957c959142288858b3807693f0657906929196665959a1610ae5db5d78637fcb94b36acc86ec2f840301a072587056b4df5ab9fbe48d461b", + "98b2792da6626b649aae1d5950e1ca2f0fb0ddd128ce992fff53868d44178046ace281a8504b1a5c2e46f3d6433d8c0b85a81ec1e949db896c3e9249f1d631a0d992da925be46800fd85a9b7bf9bf263a03ad8e345953e657c7b5212cb45be768e52d7ba375615d659ec8ce8eac54ff008d859c813c8a96c7964bffb3be07787cec29736880a180c8dad81e95a4daa132e5e1105d46fbec33ee2f0a90c45218c51f38510fb69e3ab726b5a8637c637728102540c4529e6d34543b47b81fe60211f0f6bafa9fc2c16f30efb858b4fa6aeed7b127da4c3cf5e52f7a38acd71de42bd5ef8c4d30d4b5f54b48f78d1befe2a1bcfb9b9316c6b5de189f5628b84771d", + "a1aeacb2817a0ea4eac32c19a55f7567d9462bd36a33e11cc9053cb1f65f72db68194f667e4dc27aed26d3355e54269202d0e4dee81dc7e0454287570bdec56f37f360b24c202b333e253f086b7780eb39e99094f194b6df77709e1a6af9928fc89b313806ed6ec7d6f715d20d15e73e69f1284e45b0b2f96f49dcc90878d39b904c314213c54b5887c8563ad40b7fa5a8f1a809470f84af26112c92eec234abafdf86ff46ea401ff713cdbe3708aaea9dc23be019c5e66d72d9eb845a1a37c95af9aa5c2a8868c903a80f6204d0c425264f7a58ecb5fe66d81caceadbee959c6dad86d87cb76abf3d69df5e2f5ee8780ebe76e7b0e8b08393bb9f27a1fa1d5a", + "3721409dfd047d02b4920dfad284078cc8b7e92b8c42c178a736eacfc5843a5c9afb543174ff07c616bd835cb5a41e92e23a2f1d6c0b3e16b5c58a29a8170aa6325bf2382a9c60856900bcc405b12e4b055db6c36b8dd8cd0f8e2deec528d31fdc85a93b343b1f68a47338b67d8b554c0a65cc886de4ce09b2b602d4b924b599a8d2d580a5d36bf02ce14d2dd9c8e660761b3f724f83fc8c090714bdc91997249060a1b8bcd609083197fc567b75e4267ee3f93e92d9a27c0ee1a0c5fafd10e9a14e518836aab1dd725e9c5619081c70b66bd48def2ba0a730268f645d3f4de08a2f7aa2bc441ecfa015d77c02bd99e07f3fc1bae131ee3c7a4bef747451ecd4", + "67f47db4e2ff41551f55b35bd7364013d8e79f0aded4ff6b6e7de2dcd92b81a718e79ec449f1f7ef1f9f8d0cb8b88f7764c449621bf0bc39043e73b3411c4b5b736818369e38e7bd1e4cf41c07a770619414d6df74126d3a18c84e2d39a343548ccda8fce832d454d8b40defa1ebf9a4ee3542ec4aba382665dfb4c0e9c96b62a91369ae21b0a0e827f0accffbfc4ec52c97d9f5a60ec9d94bef1c9d342083f2b33dca1346a7598ca56c44416a1977e489cd16ee9cb9fcbcf0b3abd130791e5bf9b7047f72ecdc42bd957c77a2de5b437d25967eb9ecf3bdc7e78e2c76d62036b5b7d8c6f6b2d7797136a9369a9810e34663b57b24544a43e023f7fe780b7c33", + "440d6f360dbb537a0cac2623852556fef70c0707796037e2520e8e737fd529fcec3c454fd6e4288789181a769f11f5f2c7aae147287af0fee11c98f7cce4cdf6be3df17b0098a1e4b222e8842be3f6ce50e9add7b8e78f6574d6b9f42514f27609d47f1d9b35b7ff1698bee678f7d2ea6861f325324ff07eb0f0f8a7a43bf54c98b2c99c9fb225822e74f13f2a58900aacd2722ff71e7df34a0d1d75ffcb5c4973308e568bac2a7236259e98f5cc4f1e7a38f7fa189a4b9d2c0a4df7e14acf60db37dcd2ec62611258eaa5ea3502b9da6ee3d7b8000c0bb04ee14f35bd53b30e20c3013755dd12bad7c382f8002bc5ea5bf8c871c34b8028515160e0c6486c60", + "d1f59ce8ac8fe3b44132acce4ef18c5835a795acb157a173392cb34d0e403ef9a39771e67dd0c12e8ebacb85af0dabbc6c3b98ff87e74550e0e57a04127686d04af2b80b19708f4f6d826a2dfd292f415555cb536c695e7659d37283ee1239e5249462039c303dbda81e269b32ab4e689185abf292d68f30800745eb23f99d3ee5cbb4f6e377e5660ec84f0ddf833c8e87d77a1d14735c43e24f30b6bebc42913d89aa44f3ed1d96d8367fe70f9e172a214442e11ec9cb9f743fa7716249dcf331346b22e3ecc88fc088bd60b2dee03153b9022857a4e072194d009195eaa7107160528968abb80643069516c9b7679c89e99ff0cd590a32abafd5ac8ff459c", + "f767bde0bb7a6d44f74dc4e6c59f6af15d25a5d5ef8b7e2adf24579752780f2f065d13d27358e45e9ae385acb675379e5683c48f85790e029e7c6dbbd2d35b7462480390eca200be54d1dd2019386e6b4adaf65bec336d1e1c9f2496f3dc90221314fe191f59d973ffe7d1f3afd9422320c6923c1fc6aeaaf5e60b4723cee748c4682ba1ada399c595b0f6410212ac0988cfb19cf6fc7c36cebd59ec741bc98cd013b1c7e12aeac6b14f10571cf5ab38550318d12c000877e6f1cbe87eae562f08e9e98160ff14d871396f9fcc98314aec707ae2c660b484ed23d9595071fe176b546f93dd4b2bef90abc36c4937b076952e6996779ae21fee91215139f1b15", + "3e08393da7dd47cc064b7647b20ccac3d68eeaacee72305d65c82e5f868da7055e1a7d0778531160ea735e4c31826f4e0affcbd9cf032fc7ee7f4d77f5f482bde1e8f9f3ca5e3e2fc5d5730ff7cd3ee40c3a4001cc586787a51b4b5ff89aa0f5560571c0e308db539bf96ca511b0be5ea0cca892bc4a987c861f4af746eb2b10f61a97812d9c3fb399d292a18e940b20a14de1250a09f78ede2fbc26d3abaee2abb1c14eca8e5a32552ec2b3af567c91515eb7e0b06753e192c4446f59f6148944ceea0ad1e17228a8cba1fb521e9e244ee28c632fc569afd0bf26f52beee79fb92bde2786b5b1011137ddbed4290187741542ddcbfb8f657e3340288b36f2c2", + "21403e95d5f17eba99726597cfe36603b38843eeeb09d3b457ba28c0681790729eb9e32de630ca87b61d8c12939406ef55be079c6062091611ff8cc59b1afd230b6d8b9f66f53f94f93dd00275994e7b3ead22b7cbd1697de9fbc15130d04ce28f2f92ccaafe06d5c200f00373a708b53e2dad5c6e56bbcd84fb2bbf557f385a077daa09de5ff9af00b8b0a5ad0ec48ef12bdba31e61d70ede9a76132b4b606f177ceb2bdd0fd54e86eab570ddf529b2475ad45694cc915b7b6be34c080679c5514a613d1bf1903fcd5f28d524c619c332088c62eb52443b3a934fc575bdca3481ada36da701b96cfe4c2dd7da3772234a17c20f26c66e40ebdba4d31aa19bba", + "1d93e11244ab022468be2e5d728a58202582c4f052767b250da765da33b3c79359429dab40c932000a7abf175cc46dd97544368a3fabad123df90f570e1fcb18f3a6dbcb36e1e40bc44e43679a657c143aab86bc39a8a97774bb29beb2a0057bb81e1d7db36302f8b7266a3e8429fb6bb4d35f836b92e8044927995fdc5120dfee83b3eafe83548c8725191ddce64af136558326d03e406d3d1bf7c6eba802a693bbdbb07682bc2630749ff90e66b378bb5a87fea20eca0f3155f44487cf19f57e475d2e156c823a3065429d5c4c85cff46f679c7bbd73b7010ac04e517d42906c89d3130222ef746b9e0078e4345c51663875ca96c46c1ea55181aad35f5ed8", + "960714bf7bceaaf6dc7b0edfe2618390afc83dae31259c148b8aa7f16901ff98d88e5239240cea9a921b701dff41eb1b54328499c51e78485c6277574852f540ceffcc265f1f8db2d015e6cb353c14136932a6967d72ee953f2eb1fd5f79530191f07933cf0a00f79783e8382a49d9a4743ae0aa613db6ad05e7475a871a3ab9f5981b56c8cec3b366ec9ad5d1921c237069ee3aaa20e2c9b9cc29b52784a1388fd9c92a1d6d2f96b7d72edb736aa3548cb60cfb6da4bbc9aff4a90c8e7d6baefe086c5e8cf9a74f9245c3dfbece25ea93c55a9f70986ca703bf64cbcdb79e525a8e5dd0094bfeebe1b97efb3450c2ff7d2ee4a3e2706a5d7d170c0bd4a744a1", + "74a30ae3c918a97c49baafb554915e0be8dc8088f064e70b602cf671abe802b4afb405df064f305d8ba849844b88be3fd5ba2ae29e9e80f54c7755a8ce0b3750be728d223c44ba5191aaa30b64274c4bfc5df40b5fa073c2467f422b89d6367325cadab528fa55d1258c8e38fde118925af2795901658d4c3283aa2a1f9ce4632aa9aa76cc94bc85380b489d6a56cae5f404cad1c8ed80c0d1c8fcadc9d0211447a5b509a92b3b2b379cdaf58dae0af67500451998a2104fdd18e4a68e2c935c3554516c3246244e884a8ac3c1cdf3f27847b8b755a687cd1fd43dd03269176dae04b4ba306493e42e5bd8465f5e5fc178d9c6c65ac7816b85522b3e3de8fd84", + "a9eb72afdce4aa5369af8199feb2cc5530b5c807ad5dcff803589f8e650fad23e79f519c38d9b58e07da078a13f6840f957923108664d803e2b2166fbf46c0d736bd8b110455fe8c3877c235a3d463b69a28a2c4eb3351c83913829e6c439e69fbf1275ccfa277d21e15f1c1d1d58da1235971d324df4b7a13b84239fb5af40fe6a147404c772809c9ce7207b09cafb187d1db86b8ef3c6342bbdef6f0ed0929abcd794522688f590c507d4a751642e43e11b30eb448cb743639cc7d552194e52753164852f8e5bff07602db584de20d0d148bee562ce48579a03a607d5d4ace0029d39fb8246cc7e35af613d90e9ba81621de2a0e5802c120df502f0ca3d4c3", + "24fe5dcdc236dcb9b7da57b7329a57cccd6abf9f09a691e188bf0386132d9c10e8905e08ab56d5d54d1e215d784b4294d988b4c0f8ac7790015a87740b01a4d7585c011183650fa9c354a62c51cb91ade1997d3ee53397ea6ddad3fd73b4c167139e97a9f7153c7645fb47c6c820999aac87f064815a0fab9f37914def4562749a5675742806d4018051a36c43d3b95d3b1415f57d74850d612a7ba91b983bc21dde274ebeb002fb40614668ad4901fe27db771aa3fa73dceeea72263bddc295f82210de44ef5b3887c57b2aa849b8bb5045d381f7d20da10003110ae451c0e067a6d2428d13d3bf2cfa6e4c4b594148adfe9c699d59ce6bbc6c48268beda1dd", + "8e1931de6740c1871a8b3d7cff1d13b273862232d9e1b5a06fd27bc694c64becf02042a2c57e5b07689a5f7de61f3859b051dde5c2d640814173942719bf03aa758fe54d2a612b436bcebddc1eb96d5e0353ac83be2d64248af3efa4b855335057392bf716780f4c38862b1fb513a3d79c0b315585400fb3dc58e5e198f06cdeacdc043ffe8680cc288f393387dd3fcc31ca72b8d18599eb1a6063b84ae488da37f41a8a639ff9e5a092879362f8844e55b3e922859edbd19dc66db6ad823dd608412d2228cc056fce1c68721897f69d0151174f8cca4e95cd9c8a45c09e4a2892c06e5f76ee3e32bed6b71abc191e91c7a8d0def32c9c7f86f03dd55b79c29d", + "8e1074991fa70c3de4a95039472b7a3cfacd623051a10826e409305d2c0bb03a5ed722faa53ec2c35c189264c4a1c626a777c19943957f7d8a9569e6d0679cfc8fcbc579fe8b7b3d0e78467260a9bd8b2e4d637b8f702eb5862a8834d9f1e22ca171fe0354e6e0ef81f57eba38563a684442fd081980abe08dd6db15bcaddcc0f6b4b8f90cf7c23c37b69fb96008ab067a810b96ef7100f661ae6de7aa4af7cb2d97b11eb2d2a79c50bbe28415eb2b17a83ef206b7a0e999eb0e070f065be7074def1a8327fc16a128d40ffd67ff24314d662bac17d339c5c9246399244b1fc24ce85f584b031e2d48eeaf35b5397491769fecdc6297bf437c247e043d923012", + "a4efe073a97a63bed2438bf84c8889c35061069fc9fa16b97e74a27157624cad3c4e8d9ce892cdef2366610a11cbcb4f9e86dac97fe459ea179e29fa86e80f91bc7522b40577e14f59c606c6ade6a51ca836ec9579350e7d61a51ee8feb4d01e30aa4c56224bf3fe08b8d62c08755c38b3698992a43c96c2e7bb2c034e85cd653494b63c6c6335c0c746c48b80fcc1a7faa2c569c8cdc34676a2dc4d1223f3196bb4496f3b41d014f6943ba8d83d6631b5ef8372f3ae3e74a4ca5555eb5944f78bdfc4bb3bd919ca802efad1b86b372f0b38280957eb68142ecd7cd5663be957db3d232d6c8a4e7e153e52c863ea4e9e2f8d6b864c3bf221edf996826965b1ff", + "74b945acc6c3f38605c21b677c2d63cd1120d204e6193e45b7e91d4844427f6c6c11479bd94b621bb736d56088df141e89690041db9181726bb976b0455aeab04d74a0cd27b4f1db5694349bed16fc6715c44ce75e62e789424f502a9d5ae84ba57924dbf80fafcc336538de980a7b4d8b1c5fcaa7367c6b291f5d84c3caf394aa5f872ab7feafdaa263ea96f833a1a35fde0692fd5a822f76a22009897d35a5280701ac2473f18e11d37728793d1a0a76777103c4727faddf26c8861bab486bbf4c3e5b3aa77e3d6bcb19e030b1ed853b6c09eed49f8763a548d61c498ac3f6897c470d1d9b24b76e4ef0dcaa5024e8ca3f3ede7cc76b17876c020d74f434d1", + "29b747bff626d7390eee50aef5d31aac6ba418c2d9f0437f6ddd2f35af4ee00371ff8e211ccf707c37bfe29a255ff77d5e557667cf1044f7c17e254782dc5187244162cf51918ed17e6999620b12e81f801942e046495eb8f083a05fe1aa2fe2cc929211d13671858675dd22425df799b320d1a1048cbfcb047c910af387e473aeb4de614c9b488593385c0b4efc0a00548cff0a2e05bbf0a48300041bd76a58115f93b7d57ec0a994c6c0c3dc2068ed9f4ddd53c228fcfb13187b6fbba849150a285ebacd83fa655e9fe8ae7ea98dc460d3625facf6c27ec8a4870546099d99ab0f09b006c088d56a98bc2f0e8d986d3f2823deb7f36e8e2fde816cf1ff9781", + "7c9bbd1d8f84ddc53fee9c067282eb4d149338719248afc0df9f55f805a819801c65a12efc96bddd5a47e87e3d28d316748dd0fadcec8e9397a9140e07c3610727a4196c7f9b70c23314dfb19fb7dd2969e3209f9a78d81f6d13e72382159a4b928f1fc2b141c08fbf522583814f66b28e24647f708623f75e50d462d90a481d9c39ec3c46786d7e434166c5e7f526f30b9be477888de77306d53e64cae162c19cd34eb7083603d770d54bfa3928a83222d5966c13140bfc2ac87bf3ddbd68e183016c6d17ed5e52b898df5c70bbefccb8a792e06f8e6a53feeed69cda6fcde13cde3ef0c7ba05c9167f8a2b0e3f3b0378d7868ec14909e4072aadca46a1ec2e", + "52c18d66109375f0297c540997a67657f2fb0936a490b0da5fcf197475efde066a872e75e2bed709ff931e60848e1c8bc98ecb30d0a1fdb0b2c19cad2c638324c790f0c1e4e879f84c8d892115f0d9118adee108da9f36c4a68fa0a43e93c2540b3c9bcc78e93f15c99d59416208233fea3615f993d21ab26d0711f6964587a40de61df7b67ff7e5ea18373534f9e74382a19ec0f88f8ee606202d6d90df8f8621001d81c66898679282670e7739bdb86054e3b2fe9cde289fc9bc48134832eff2b59e1b6bac6ec487f36a88477367d1ad565bb594d5741be94dedc04f7b2ed81c981ee5052f8a7cdbfdab942edb92a1fc67ff4c47b8261bb5bf3d5e36c55fdd", + "9b995fcbd90b493242801ddcf52bbc4663b0d996770a7eff661e18d7e6e43a03a274f24c631cb496b224cc08ff2fd9ec1f0d71c43f7ffc2fdc0a829d9e7e84f084f616791b43ba413e40232cf642790218940419f027cdfd2349ae20411e684d6022015268b030c5215cdc3948be95cb758fc608fe5a4e06af01a8ac20f679d1e9eefdfe5556929d907364850937014c17dca07556ba8f1c2e427c8a98659c3cd4c76a74a04726928c558dd5c30f39b2b4b8bfa02066929ab357a4c041f6c58e86ec1f1e7927f12feb13bb86491cd45b00b751c2b05d069d39b45bed3adb03483482cb088a2b87e9a7cadaf02df9dd3214bde184f2baef72adc0d2ae3feb707e", + "8d85093be3f0c4f8a0d29176a94bf5e93e57fcbb7c363e92f07684c2008dbe1fb91ec615d1c8c841594de9eb6105f2d67d9bae856e95e44e3136a057c1f31469f13f5e21442c17c8214ecbfe6aba256db65bbad18bfb596df2f512c6b5b91c73b5c8af9ed395f094f6cdd8de3ec4049d10e129750a14386be842555aabe84c408c96fce1311864544b35205755909bb10fd6b0f8b013a00e04897153dabf7509fdc8ec562534b91e95299de50b37656affd99c4e2094807bef318c8ffa9f94060480d10f2ab2cc99f95af7efb3c7e6b2958ea9015ca62923786d5628a3f8001bcd0f5b10b19cfc8ac578e157dca59d6871ae3946b68a8e4ce1ca3700127b0e15", + "57a12764bbd72f15cb481da2fb283caa7e41a6942e3f69a08183a39d9410f3a2757a40e1e97ebd6b8fbca7119ddcfec26555e50ce1cfa05c9a71da2a1aa1dfb1668f2e10a34ac38eeb8419b3f64b55c11b03a4a67628b2fe0ad793658f422cb7f0b22ba4d0fb060506a1397fd99180a4dec1190a3c001666eb1e34285c357771b21e90bc9a1eded1ffcb0041f30f70978cd09457b8870697a76b79ca838187e15eff92102e9125bcaceac711eaaaa40299f090df6be78075bbbd7aaa905d5788ade41634decbd175dc7a9d8a67395d54dd0bb76e3102b5117292d502f8833a39a978cc688a9cd223764e98e8cae9a37112a7da56f3f39645e45d6fced4d4af86", + "a0c37eda18e68495f3b5c791b22ae3077bf1d441ab8d0963476e7efb53b3313f21873527bf3758992ca0fba3f220af566e69bc23f1ac1dbd21388a32f5c549482f47bbe6e1bc8c1b822b58e7b5c60233a9fb9a83ac568228dd6e28ad45a541bcd7b303fb8c52c99e2ad6fc5324e2c91c96d414712c7d04ed3bdc0da4c2d26fb12d38113a8d3da4f305f6573cf687e6dbf5280362a2a0104ff43787de6e4fa16d9242ff6c086b474c1c284fd6fc8d8f39abc0a4d9d253e5597a7d2082951a14c56cebd06b6324c7dc6cb3ffb45e6e41147e0a14e140b000457d26dd2cef2c4e86285c862563cdc44d2fc07cec987c4287cf67e3e61c2d16fb013fba7ed554bad0", + "6684e12270b4b17c6dff1a32662fb99a8ce1e78a2740dd3e9cb7162f61f8c11e1c78aae4f2d12d74564cb53e5db3d512c29e9f7e328bb18e7425ee646b8a77ec4b8e1289ae74f42b51df984df6d54695ad4fd60d54bf364502b1f1f659fd8da1765b05ba0b3f1176a623e9990cf487c591e42d2d6af3a7eae9a5d446314b23deb2fb2a02a5d20285a60b92f4cd60706bab6fec32172900ccd9fd752ba803f9cbf5dd2dea6d250f39a21966ae521b7b56e72c81bc0311cd469667e8fe0b0727739516ede528ab32c6700488bd0cf6843ad9afc4610006bedd8d8231f972ff89defb89c92cea7163dabae10636f9b9d44390b507f2fae467ac26f539e15f822b64", + "2b505082ce22ec2d36e122ba80183ee75cda64f238101b54747cce211c4387e1ff741a9ea8494d4973b726e0b2a9e84498aa166fd43577eac91da4cc11097a404dc7d4c0031d0784390733a89013cb9cfdf8b35d119f157bfbfd566d02c9780995fbdfd67345890f505dfa0058c04854187c55792e2556af9317a433ed7b0740ac70ad0f55efd5e7e293c009f19d3109cd46fcec1612e9593803122cff5de6047004f344ee1274b93be05c84ea027dd0140d7c95b542b949055338445037abd92be50bf5d7c86203db7575807d9c6e32d6f6e73b85f2ab97dc7b4c39da1eb2fe0d6b050254b04a9109714870af8b1dbaf9928f0731acbf3477fdfd72d456521b", + "9973cb9eaf649cb937825f97c0b053c11e7e25bf6e9ae633f31bad19ae10f90417ea3969dc5221c35f3310dc1a0424372d57ef0b385cd30843a74f1d899c327ae5efadf9918c0f8c67c8ddc8e578acc5dde7c46d3ecbb2b9b0d2d123ca3f41d2d1b4c8dd32b8fd4947c207136cd5fd6b45c50bfeed111269d46e06a44547059523e6bda292c6f10aff83c6e2de0842221f7b072df4a7bc2c5c7e0f3413170fca9be86799ea77b1b785f923a900efa006f5d53430cbbf1206ec29acf821e18549fec87002e35fc1028e297fd96f62a8b097331585565bfb438a750e309c8dc3a15543a260107611c3c1563a26738cc3bc99cbde02f42f663427c36dd3a20721e8", + "1669ce0badb556721b9eabca22acfc0877aced91ddb910a73a10a3ea94b8e006b392dc920759ebefcdb8676254cdb67c839266a8e924c7387940cf18b0d1aa784369aa1beeb07d3e511f5577b5dc6d1b6196fae0511cb14d01c812f493f15da94912b59ec19cd22c016b5bc4e6385c312e22cd025e9f105df7d02347be3620d0825fc52d76622982572d07c5b4c6ddfd72ae8dc47a8244eea4abffae94c57f3dd01cb2ad9ba631c73b9eeef38aedfc0cb9b0d934732882283e1753acf71e40034dd9d825df271dbc47cb4d3f0327dceb449a0e572f283c5265011f9f9ccf868417b41184b35429ce7d6b1399fba7baf250474d0c448861f926ea1e2faa1c32e", + "78d8cadc538fda3ef5323ef687d0245a722752e1f748f326bf2a50047e296870eb997cf441a4156229a4eb4292ec1a32806be1f8a1808e71f55aea8a638a8a8476ecb1bc1011448e50ff2f83d220fde781d0c7ed09bb1b51f42897eb3a582cbcf18ee309a0c74101d446a7a6e7f83b499196e6555041a1352907ff9dae1f8c8b61c033b79563a8dcdb500d340696107d06793f190e21a7a27cd4146195712b873c1cc19633eea87b645665738ba5475a76be0a4e4a3ed0578ffec307da033dfeae3e0e6f005ec68935bf6b633ef6944d968e1520cd735e7890ecf6e139f6a18e52e6d5992336083520562c0b34def46478b60d608cd0bbb368b584a7af9a0ebc", + "a94721573aa9f025bbbe7d7db124dd60ac7d68740784e448e9144cf7b9407f616c2b5941550bed852fa4757947a232aa3f09970ae70491548bdce5065c58e67bcfb8acd12a341d3194582e61c0ae039edae8a4fcbc30e799ae0f6f3d8553cd5363513a74588af77586f0a51346f4e6ecd489883ddb2076150c97dce110e81ffc277967f355a33061dd0a1f880d6284cf7a01e71f9f0c536c91ec9c47a5ab58f2c11aafc060750024e7177bce106f8f807b5e848191e8cccdd8ae24395ebf66ad7d8e3517f6a765a558208c8ec00920a4a1bbf937396871305ca1c5534387829946a6e1c88039e7d35996e56348c5fa26e958f65c052b5b14e5538a666349e5c1", + "776ae48d4bb5e10d588e6656fcce6a5ff3c3f1917319ef8e74a0bf6c97b0aad9b8b9954c4e6dc6e66c7f88930f11f45f39097b57b30b1f36ff6d736fc1e2720ba38ffbc1576a9c20b45baf11cea86c4399e95ad7a9cef22dda50b5e6323fde64f2e68c5175d88f5978755108c5471dbd6245b3e8ee38900ae88e1652f460733d3b2121b0a756a6e2eb0b402dfc01a28f2d407e25897d155b255c1b1d284b418be8045524d6a22001154e01c26118508aa867e09609e81aad699b88af490c973848794776caf77f1ce6d44413a06263bc99c31936f4401e71b9d714ea1b756c5251ce68a3f810a72dc7c1f65e5d87711abc1edf894a6eb98d33f59d84c71d2689", + "79bb379551cd64c86dbb27e36e8a05561946c94e8333eea36f80fe7cfac886a2142a6ed80a9a1dbb3adfa50617e659259a59a48cd7c6b8e15479baafc380d8f3f68de96ac2f27032b2a88a061cde4d54958336b3acd308f1e2df81b2d9e0bbf19cb364d5d676055f09c976896450b4e5919626a7f300b3cc14a6e01cc92c5c5af641b9661204406af94cf53a7ff730c362a0fa16d203adede9e3f1a22177fc92bf048926401055a5b4920695230c5b70028ab18dd1d1b87d372a50c530f376a970832364d11d9ec9797770e1befe97dd1254b169332a14c0518cc1b903840b62993af3f25ea309d6605ab46fbd58f43de22e58e6bcf02ee518ede613a32365f2", + "49133ebd9b9a768dd7d4d60dd7acf450616fce96fae917a751e0335bdb05f5baf2fb147233484b2ea176c18f04a50331eb07e381c581d6adbb5f7e091dd59e1de32232b9ae0a1a2a8771c30cb80c042c24acc275ccb51bd160fc19ff5d534f33d4d07f08d32ea0cfa3e3c63ca2f9bfa397b2d78a2f686d75a9ec68259169d490e738b62a28843ea5b65c50811ed2768d8f506beeffa5ebd0d6ea351884e277eb886fbbf05d3e69895f3a83ec04811f95ff586c0232d59321c996b8834c845cd2ae6ac8207e96915b8ad2a67c27c6808f182801ebd564de92aaf0bcfac5b2cbc3704eaf90f94f6eee97ee3fc0cbbbfc488d4976afb477883190f19c7cae327a31", + "9777c0e701577851a96356cf559c95b32585375aaf2bf7bb555e066e85d42f567203aa5a4608fd7b25d371f629ceec719eefa8a84b1b059eb38152fdf3d74b403a4e347bd671b8128fbb6a1d8dd0dfa4ca2ee46718dc4e69d286e9f774768e443161f08631148f9a7175736e37b113ff28e8d0e576e1a9f42c25bba7a50d05c11f22e5d6cd9fe0ec8fcb7b80d2238a2546c625f52a53fe001965fc7a4d1a999dcdd86f0c10921e2e285178a933fa1241a318338ccb346f190b390c5b294d28e49eed19bf5000ec406460e4f30feac08538c5612255224948b89438932d4f3af23099ee9af6501121730f3ad1d67298ab12c27e02e01e04dd11d8091ea38ec384", + "91ce3eab50d9770cc9710a7b5cdd247b89d41c2d84340f30a547c618837b6c9f12234afaec821da80b57b677185774cf2d340fa97cf49fc567f87420832bd6509e3b72497dc277c376929f6697f28f7c08402b073ff816e82cab00d9717b9b4c499a2afe646f02c2b6eb0874ce9ba291bef9e5d84da13520cf84b6b1f946af10c9461b2c0c99583022489ae9262ec57271169c377e4b33452f289fca583fc48c4db53f05a046ec1db2fd77f34ff84faa66b302f3fdb7af22aa1038d7b2fa0b14537fde1f338f7b9b821631067d699a1b2be204f8dfe11e4a15dc3fc9790369cca707bad1a5ec845f764145881cd0bcaaf8eb3f84b159a3df6ea3523c9a7af23b", + "6e72d9a5bfb56ebaf64badee7e060b728722ccb93820942439841d321a6a9263e007cc2ac457bed15e236dcad0af32fdf950a6cd547bc61fb4b53813f410bd5685cc8372961f1a915a99c60683cc7c7e3ed46af42bd909d6a435e8d59bb6553f16679f41960f79be0b193c6f64bb64969a3c81c4993abfd82432917169c98ab1a57d13f6db506097ecf136684c08defaa6cf111371e4b041147de2f6901e22a19976552f34e62721924fd2ec65ee441ec515a6acd4bb056c312a262e725c367c2a68331d6523723e381467e722773d84aeae4e301279ed443f524bbe2c2ebfe20aa646fee8f06f36d87c45ffcd6299af6f28af1b089fcadfe895f6434dbbc360", + "9ee6734172fc83ffedf08ab30869865399e0c3202f992f6f2102f3fa64d8253ccaddf9398da763921c492fd7b248e2c8397b8f52d559008e17dfee62a9a26226fc6f3f7d19ed25437a14f727d101a304f64b03213229ce0d6f9d0cbf9e1749734393422622d244b07c037e1ede93dd8b8122437c7d73aa36ad36c7a2bf523b81b6b49c5f5f14c5c558a82a7227fe70edb8023be28663f558a7e1adc819ceced5e48b9639becc2af30af34d4c18f2286f5affc6dc28d3fd189fe0c78376f41411369917cffb23d140f686e99d09f5474091fe4b3466e621507687b195c5176abf01ec41784371b049f2eec1111c5ef9263f51f10078adcd008241b1cc80454abe", + "16812e25ddffb30c7cba2aba93318e4e4341cb6acbfe711e9787fcaf2219917344a9f541fb58d003d60a9709c2c9e64685f3aac5f1bd83f138a3a75ba4dbd18cd59b8a9541075ab63bf62b4f594ed66e461c70db243df39f8a5c1580e4b4af23034d8645685dc5982a6bda62c41d43fd10a45f8a32f084edfb32fd0ec92e652384855147c46b7f06ec8e5701f252ff15ae17b23142f28a6caf05bf7dd0a52a561ef35a2fe98147865dd95ed1d23a726caa5c57384263ae29954ef1408868ffd8006ebfcfbf9b7a792eaa5f9d9f99c8b4e2637246fafda805025b5d058e79c813de3825ac42b98c2621feab6628653317c8b0b3b204bb8d260fde545b23a60a4e", + "19a37024d388236e6cb7ad0ac029b4af0975cbf3c57d1abd0800b51b30c08a816fc8b13d50a8a6e2d729a68152442dfb81210a30cccebde714386f72f457898fdbda63ae3923e072a060a7af8508b12b2daebc8eee834522468825d6a87d199eab86318382a37ed80dce27eb0c589585873de1af174c7e96cdbe24021865621557b7b0b7e3cf61ecc7946410b36b7cfd927069915cf1c39c309e19aacb8321121db51bc584f21aceee10dc8d2339273e6e6037790b131a48ff5e892316929416288b08119d77d9770c7ed27d9deeabfb9e64937c3763773413b2a57164892a9454399d6f8261a4b349ef630f67b3961507133ba3a89e97ed0ff88ae156a1776a", + "73462ab8db0ed6bc854c4ff40f51501baf2de63ebbfc0bdfa83494316f69dfd9bf71da0c6839cd6895deb115ce17a434b8858ae89c8d3a126ee4d842ea29b49e75ec21dc6c92ee1b0a11a0fe4810395d33730b1c15a28b25b2de8f8daf3af4ed2c5430eb795ccef4ee24d50a859dce6c5c2fefa44e38fead813f86b3dd33598d7de6296cf26f5a4f3fb056d4368f6a19b8d996b7fabf9b7d9c9ca53e84d964d8aa668b2a9ba503629955af0481440c62994ce10aa6a0210ae778f96ebfd5555e9c68a66768eddef31f073522ece202d479606f0652cce845dfd6df8f984746404122c9cf1566bd3913a8a580496fc0593b52a94788da278b70445a49fd8a963c", + "58ec7917f8af472539ffa195b8abcfb0c944c90ca90e0c1da15a4abfa63f98a79d11e81e64e11a0634293ae119d71e4142444f5d00bb4308e8698be30a16947e6625932ed4c777169992e69d1d4565ec4138de9f0d7e5173246728b9c52a8a78da4a4ad0aca08d9d40f0bff43141a858a6486255194b003f0142695f2eeaf92b9de3943f146735f1f0407d49c100af0c3ede1e9413ef86069d07ad1b1b28609110b1f246dcd6aa869cd66376997c44ffc2477b83c2f8a70d1e06d699f6e938f5f47632eeb5bcd246c86f71f9b715a2603c5834da45437ceb3640ea93ed75f0d536cf653f120ee08b022dd6244bfe56e582671f605e9472c6023d0a5b6388be", + "56466fcd317e0d8ccb4f92bcd2a2d8489ff6e4beaac452cb102769dd25fdf6b51f457161dc06a513ff1a8f31828331b7aa8b7cfb5445c7c5dcb57a554dd1164fef7e3596c1d33532136835d421a7011b151cf02c39e945cb7ee606e13fe18dcfbce6bae314a732bc6ac54e1badfe2aec42da10462fbaf755a9133eb6d90c539f54e557862bd65c4ec447e0e8be2be84147ff619e1d90b24bbffc89a26ba7996f805a5b0bcee5cea502b212ac9980add4b80c39694c6f0b1c774995d2fba756020c7204a4b3659c379ac1a8533fa4d37175bdaa79ae6105abb67282540cc2b8ac347149ee64f99306b447562869c6b7431073a2f4ac056f8ddaf98d0bfb600b94", + "1546cc06beaf03b3516c77ef31b9e563291c99c56adca38afebc74af6c36966126e6a58b16e80fd1cbbe9c1e314934df21c58fcfdc13e5dab0bf8fa897c41ea5d23f7eded36b69e08cffbd035378829e344d4b260fdf69082859cea58dddd155b627b265088c680fdb8600f08d3b15a4e7b0b8dbaa5180cc0e9b5124b9aa3b8a9c3f87a810b8063307b619359499bf3faff284e0eb760af961fc105d2375e98563f33a713f70cc83642e9d840e7b45578f03c28b0a58059859b56cd571d299fd9f4198a0c36c13d9932eafcd0918021020e50df914a3ffe4d489ba4eed72775bcf75c4a379341bb3409ad2bc1910c4eb14d665f576bb920b27558c08fd202530", + "26be926f455caedbb9cd31e0ff05f5860263feb0311ef41575a984f23439cc0ce6509e09561b7f1589b487aa13a7ea0cdf558db6d2e8e7cb967a243b590c903c8c45064247a1e7376cc42d9d2be97d1b94b5a88deb2f8c5e4a4ae4ba871703d0c0d83973aa0950fc53ac40d8f03247ad6ff9b682aa8a0b19e557e0b0a06d16961e8e3a169b7d0b4f818d96242535f30904b4af34bf5727341161ce13c3bbec4ad29faee971480f9c366614ed364765073bdb70740a88447eb0a8fef1e228fde0e1bae471a64d792464f301473b12b9252bc2276a6d0518309847a55e04efd8d14007c274221a75768335ec7c6da2ad6210a131f2789d7b292e5cd8f05649ac2f", + "7083a3c4aca56d0cdd79c4b6a8cb82b71311fb1136186bd309d70a97636f5242397e29ab241d988630f79b20d4d0686f99873bd79e6aa9224489b046d75f7b15b491eae8d3382abe56a4e78374643f2d2623f2268bdaf5664c6e395c7c1855d7fb71f852dccb6a1c2395c4e83214691c0c2ab92ee14896ed084bcbf6708dbb747e09a36b0023434781a935797c18004f96e511f7b5200063d5d3b9e4e4eef2e79626eda77ba2c4d4ef575e735b2d8d9cf52eacb48a877b021f7371a74081206d1b741889907636c171e9a9d74251cdfe3441be87e693816fbfd89c7ac4895127544d1ee8324e93d5c1da1671c9e37ace0e044ca452c3c4fc21b2b203d75b697e", + "77d114b778f6625a363d6275490d39a68d0009c2bd1f419431e80e45ddd6c3e36bb42bab6a4b6df34f329a37624aa8ecb1bd53b8ad1d2bfbdff41486b9c67c0ae2ce75cbee14650488dc3e23d6c0b432545e0767dce60fce982342ec1e1afba6c134940a16a1ed15af6eda6415be3e56820821a6e83b509dc5f3b87c83247d23610df4ae37ef12bf071c52ade358fd12ef798f0a878289265a90a74e48e70aa1f42467983ebfef3446e1b8d5b2b2969c75d4bee1d0f380e16a8f6a46cac28fb195ce6743133c2109ab323fd809558353d7e793f828b78e8e7fcd9a45057a371320dd6386da842652d54afc9d93b1dc8f1dc64f23f98a6cc43a4e16782ca73e44" + ] + }, + "provenance": { + "go_toolchain": "go1.26.0", + "input_fixtures": { + "keygen_data_0.json": "d9de3a0fbd8ae8f11c7d194c71be7d40b3a9581e1b2064f1b5be10ea2c2cef5e", + "keygen_data_1.json": "22c591a6caaf2f5a04c80ca88596dd07358313627898e26c602214b10a043629" + }, + "proof_source_sha256": "f2aedfdecb925dac8e420ab9506898d0dd095efbc599d792b3cdc3ba4c7f7656", + "random_stream": "SHA-512 blocks over UTF-8 'R01/' + proof label + uint64 big-endian counter; crypto/rand.Reader is replaced only in this generator", + "source_basis": "github.com/threshold-network/tss-lib@2e712689cfbe" + }, + "range": { + "challenge": "af67a33fde217fd5e07f93b87eab1f6e49fd15109e2a26364dfe0a258c6899c3", + "inputs": { + "c": "3a0470bc36ddf902d063c077b0e557be98692bd242c9cf3506ff8838fc019f41c09fb4d9a452f2922a72dd1ca9f8216a5efd85c11181d01355c852005f496b5080af601fb4ebf2d23ae45cbabf50ad517b2d2cd1247bf20d98e1739a00456d72cd39a5a7f5d2707c63ad633eac0f0f271ac2a582a79e9fa1988c508577345b695d5752346961510a5328ca33bec0d667d19f85fdbfebe3f9c20eb1fd5c701e6d0aab0b584fca16412874c097dcd6ebf5c6bb28e53e2e6b3cd74ac17130d5ab82f733a302d71a27fa569c82c58e9874866c24cee255245ebe42800999ab18e9ca198e2d518ca20c1c215b8dcd3e741cb9e3cc035102bd8c9e2306233b4c50a4586a484470002453eb61d1d15d1aa76590efe3a20bfc83a2d1477aa60f5215c33a6933ff0848c397e2cc61d3e4dfded65616f37e9864d170df7584ea92094b7dd2a6941a3252047c9704843237a5479708b796dac71cdb6c683ca118395a986bb08aeae0df859e9a001f6e75527d0dfdf2291b9cd690ce400f92a7a4d68fcf70926bbc25dd3369f01c0fc1cdbe9440b5f8f19d3d5174979f5bd1c94ec3e4df0c09f807aef71efae41b27351310374ac7cec30145b9284cb7c266dabf201471b8fbae21f24575a3ba3060b907598200c9607b6f4888c04598a9f0b69246b027d44b2248bf5cf7c915e5769784147786aad77dfa285b398e03580a6f3132c3189da0", + "h1": "f21c50993ff18390db9d37e26621809065359c0ec1a70ec0b90b71dc10a070305519e2dacb54dfee66440cd4219c0bd0e456631c0bd326627c1005f36e02432b03447149a4ce0e62556531fe907bbafd11e1059af12fc1fbfffce9205222e42b02c18622e88eb0dcd22f098a905cecefe4672e7e8abe97044f1b993f5294907a5d595ec23179e82717978d594f205c5c3e904512cd998522b933763b3f0ae56ee684c1743ca21c86b6f98f5200fe352f3c2bc5641d8146077755332834cfa5ff2663af15ca0b7a239be9b661885be6f39455bb4be1c3b54c2d598683c9731ace5f19ea7ed5c1fa85f8e304a50833bd1a66157c92ba2d91f021400d736e39b05", + "h2": "23356a7ac492a79b204f34ad22f474c3fc03f1254d2a4d24ecb68a670f1cacd6c2d6e9522edeb8d8e58da89587ca88ba878bd2d72ed3ce74104996a937d7a5b8e68b26200671757e110764c16b2ac2671e03c56345cca8bfe43eb514a8c7e1f45d05eeda3b4814ce63ccba37d47756efc7436dc899c4fb85832a10d05e11bd3210bbd0223c19fce9535c0d3dcbd3cc29797fc16a25e5465c400fd0ab9e93dc4c8b3ddc0e736bb5034bb20ebee475d4a837979fe6dac91f967a90405268ab6293498592c15d8c556ca5e893189f20cb4f93618818e19ea2fd29b44cb3bd3afd7641d23eb22151f25f37f6c318531d2df923ed299444883313bda323a591c695fa", + "m": "5", + "n_tilde": "bd276406344107286ef49a2acde336f5975dc24bfe350d57501071014b374537099933214fee6277bdb4138a1b5127a2f4417c30c9b271dc03e86896522a1b18d25f545932f91ceb5e037712b1d121012c1649a6d07a6acddb225a6804e58ccd9fc88d5c872ed5912c5f4179747b828a3a9740331b0d4e2157ac88b517c8f7e01dc6475d61d60194c31faaa5ae381c2615d7f1c4abe0a3e544811ecf0d1494461066b354a201a78e40e4f289accdfb15445e1248808a31590d7a70659f2c55721ea4a821610bee961924a3af65a0a601d3809d2bb9e223b94c96b2f2ea926af0c2b88b95dd334cd683f3ed3f5c446e918e9b23d219c8a9f58631cc94aecccfc1", + "pk_n": "ab9acc348c6290f126cf3cb35e29b71cef8cf1c98d21f22276d540efb4f2a74a722d2b2ab6fd3e400621de109fa0c82104a6111d476da33c679fd58d32e32551e1f8e4b39fabd9ff7c6e5bf76aa5b7ba72ca79bb72eb68ad72975a6d1cebd0bec34cf56c9cab4d39f6280206b001d6495b6e1c58f3b050be29e078aab5cc45cc201922715dae7f72bc8810380a38c17b7838e6a18b804e2a25d2d22977fa26dc63161130464af47dd5c42dba70a85a0bfa2e3ca4889abb3cdcbecf75165ef6345ef1e58f9929df65ce9bf33a53e8f1ef18c73231c70f21a30c4c21f10693eba687faaf5de5f3b27e020527539b3a8e8358a929bca06c1ff6c3a2720ee19bbcd1", + "r": "3" + }, + "proof": [ + "249fd736045638592a87424cd8c566b17a5156ac41982ef61c7bd83daf90aebd19d7c9ad3aea52a5ff4d4836d8f079812d0832f148762aaa1fe1a758231c3c57e37afccc5ae932c0fd708a61d537766c94782e4f46e11d63b8f0e6f8f6194bab581f01ce01fb3d80600e387a521be45d9fa5eee63128f8279f41729a4bb36f487c4dfdb0e88a4abd83969ecea7d266eca50528915eebca6d6a7cc283a4a5d8d3eaad441138d27e15778fc1d0c347ae769c42e6d6336a66ff61216410e453a09a3833efdcbec450a9f10ede5e139e0af5d9782746b02efc85dd1af890320334a14c028be47516e259a26d0a45a581447d69d65639c654255fcf7403b7d0415c54", + "676a8bbef4ec87260af2aa1cf9ae62d8137ae4886a46171879911c7a091ff1410d55163f07d94be7f19c9da05c3f180d57b6952734e32ad2bb703d2583c3405c19f5eafaae4dbcde96f3855659afc9d7a4c932dd7e491742c0248047359e6fb4d2d6e297ba6dc633f49e99ab258d31334d59cc988b552e62e0e456f4a0fcf52f5e9dad9a166d6aa92e50c1c2f45a689958977a62a0cca2da94cbaea4cafdb685da0a871b3a20fffbfe00dd237f817a106328c041f4f0baf12bde085b4a522f797725ba4b84be2df1b52f7512551b7b9d1e31401fe377b06e12853b265307039e9f2cb114aacd096f9cf88a6ce941ac1f64b35e4347e6b03e8992c366e3d901c9985b55b0432312edbc5760182ca13cc5206a116456aabfe5eee87e897381a2cae4a30807dbde5117c0e2841ec03d0437d86328efeee6b41092a49376ce7bdbb2f6f3be6f1d60c6ba63b4b3f9f8c2e38f82581a321afd2b7c0658d0621b0b8ba62a9149dbdc49d6c82fa3471b5c19d8746ccfb813019cee1698f2fb113e53f4da505d85fcf1611fe5316e770104e654dbb86e07236595033dcba6351da7dc28c66e879b57ab749592ccefcf8d937d64b841bdb8ce5e6246782f4ab58242e8150964bc5d2f5eeb129c72224acf6e74b647c55a54a7e9f416e0e2607bf73935625592d0e05ab3afd0aae187eb75768f11a4aafb704fef669ccebfabde1798b33479", + "1d867375d7d820a408b1f9b8465917a92c9c96b7eb3d651733aa3dae967ea8eaf4b2bfcd701f8fdeecc1eee31c11de150da463438e76a416d4c64d7aee414eb25f4f55c880c1ef538f1e484c5b7f65e2d9fa7e5102fbd8abdd521fd190bad00ebaddfd1768c4ee06048e588ea77b292ccee31f3cf619b732828dba90ed71ad7f01c588b44dcc297ad7341625ac965df011a3349719acdc5104e5815c5fa530f9950b7357661234aac2b1b7d457141319ab9e92b232036c0d8c42d89d92da2b8f24353afb5d369bc201c891bcf70af799628746a73de5f8a1edf1ebdc7d04b01c3dfc172a5b6975730f31cff5122c92b9ddbceea6357560b1fcdaf76a1f9aa7f5", + "a6907cec2709e05a31ee3f8ec9c486a13de2691177ba0c4aa5ca0ddc720f83fbdb4fc98692886d300facd2d02476a59fedafc637cd1ef69d2e015587ccb2b3fdd6e8b40d39d11dd496ec382800a4967910ff84fa90125c2c964f3f0ad9f3116d6c8e5fd334339b3152e901e63edbf30e667e70ba5d853f49081aa3f8d5a34a0d6c7b7a4e24e3e4d4e1c8b3687688dd343217e383646a7978959e1a9fbe7f4edab13e1da172d882aeb08c0182aab8d7c5e27adca41c8172fd40b4d9aea21b1781bcd12efd471ff13fff7d198d82fb1c64ac47ddceff0e4655d63a0633e2da2e4eeb5c2a643a88951babe11d8920181f42e149d5b8086799a0aeae0a57dbbc8eff", + "8a65d413baa8824feac3aadf5b898131c2c310359a7644489048022a91f21e973eddbecd34c7b712e659e2734b51fab86fa655975b05d2624f28e570c2871f6c79f084cb5468d6272770cf4b7937b95fe3097fed6d2c44f49bcbf0babc46b9d0", + "4eac3e73888e92848ff07d543d661eee437ed9d40e50e302773284bd7f9885fe80f297e2f410d360212cab1223f57f3feb86969fa9bb48d452d9c4927d06a190cd547c201248703c0678c47ebe48a96dbe977007aa9b082e5630d30d9e74896c73ce03a3de19b9918d9edafc3155501b6b3ec63b379be514fe595862fa4ebd65831f7d0c7477a0f3d8da4762b49a7f7f2801b910350076e9176f338f0efceb75c8add3e42525f3ea3a370e4999540852f3648e42861e0c2c23e77446f31b76673b061d6ce9ebf4a25aac67bb051608a8ca147328c8505b34848ff97e333c7d2370885eda94fe908f6c3de180e609f4c9fe00900c72d576578934083be238d9d44844df96648d529713d297989570267dcc86dc464871ecff49951fb554dea5a23322c9bc26cfa3c340aa7ac372f4f8afa8a3033bd3b9a8060874a4be305c49e1c4e1be4ebc4cdbb2d9cb3892b392cdc8b4814271a7b48856024d68eac643c73a" + ], + "wire": "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" + }, + "schema_version": 1 +} diff --git a/testdata/legacy_transcript/prior_v2.5.2.json.sha256 b/testdata/legacy_transcript/prior_v2.5.2.json.sha256 new file mode 100644 index 00000000..8e4aa8c7 --- /dev/null +++ b/testdata/legacy_transcript/prior_v2.5.2.json.sha256 @@ -0,0 +1 @@ +41c0e14b086cb3046353298887edb9ba08e2706fd38df572f425ff5954bb9fc9 prior_v2.5.2.json diff --git a/testdata/legacy_transcript/r1_fixed.json b/testdata/legacy_transcript/r1_fixed.json new file mode 100644 index 00000000..9c860cd3 --- /dev/null +++ b/testdata/legacy_transcript/r1_fixed.json @@ -0,0 +1,796 @@ +{ + "bob": { + "challenge": "63ce7957914fdb39d718e50414d71e9b1dd4242af37aa1e4f67d43879ffe3e1", + "inputs": { + "c1": "3a0470bc36ddf902d063c077b0e557be98692bd242c9cf3506ff8838fc019f41c09fb4d9a452f2922a72dd1ca9f8216a5efd85c11181d01355c852005f496b5080af601fb4ebf2d23ae45cbabf50ad517b2d2cd1247bf20d98e1739a00456d72cd39a5a7f5d2707c63ad633eac0f0f271ac2a582a79e9fa1988c508577345b695d5752346961510a5328ca33bec0d667d19f85fdbfebe3f9c20eb1fd5c701e6d0aab0b584fca16412874c097dcd6ebf5c6bb28e53e2e6b3cd74ac17130d5ab82f733a302d71a27fa569c82c58e9874866c24cee255245ebe42800999ab18e9ca198e2d518ca20c1c215b8dcd3e741cb9e3cc035102bd8c9e2306233b4c50a4586a484470002453eb61d1d15d1aa76590efe3a20bfc83a2d1477aa60f5215c33a6933ff0848c397e2cc61d3e4dfded65616f37e9864d170df7584ea92094b7dd2a6941a3252047c9704843237a5479708b796dac71cdb6c683ca118395a986bb08aeae0df859e9a001f6e75527d0dfdf2291b9cd690ce400f92a7a4d68fcf70926bbc25dd3369f01c0fc1cdbe9440b5f8f19d3d5174979f5bd1c94ec3e4df0c09f807aef71efae41b27351310374ac7cec30145b9284cb7c266dabf201471b8fbae21f24575a3ba3060b907598200c9607b6f4888c04598a9f0b69246b027d44b2248bf5cf7c915e5769784147786aad77dfa285b398e03580a6f3132c3189da0", + "c2": "47bd93dfb917580a50a07d4256088d264cdea88976a014cdfa3006897db3c14428ad683d28d7cbeb46a68980acea1d46208cbbde05cc059d11a2158ad69d7ab648ca626388dfa4f685bc84fe3e8abdcd7888d150ba5b93bc58184aa7f6ea4c13dbe81df6978a34526de062c313b851229a41b772941c254f582b6d5efb8bfa73a8a8f3345eac51a5c7a132396916b2d4f6e5265ab0d8b51881197c5a9eda07977ae438dfb3716ca4ed01620c34ecca532bc0e68772a0fed6d576a9da65313de26328f790e66449e83631491d4281ba8487828c11a284ea168960461a92d59077676df4b52aa94341d816063275368e055f1c019fe9f952554efcd11e3c1d55875fcc5e40a67f69036fb609106cc27a2daae2561f5b2ca909c126499cf801905e5054df946717e814a6bb592900d7a317a1265640fb3efbc8bcd3c6c15cfc80f8af1670ed765590ebaeaac9f8457b036f3e15d82b26bd96764cc47953ab2f55a45c271b5901955414ea9180262c4d043a2eb690ba866df53c7385a8ed07eb7c26c93118f94d0f2fe485772d2d5033984938c35f7f2d673e17a2d25e344d73ee791d5a898164942cc45e0e089cd1f88ee4bf6adb16ffac5a8d943c67db8fe9dd8c80e7145c170ba3d5290565026537126ddeeb5a9dfcf9fa01132be57ba3b6be6e5912b64cf243c37338930903c6bfaf60c0b249665fae514e4d47baacd6f1add6", + "h1": "f21c50993ff18390db9d37e26621809065359c0ec1a70ec0b90b71dc10a070305519e2dacb54dfee66440cd4219c0bd0e456631c0bd326627c1005f36e02432b03447149a4ce0e62556531fe907bbafd11e1059af12fc1fbfffce9205222e42b02c18622e88eb0dcd22f098a905cecefe4672e7e8abe97044f1b993f5294907a5d595ec23179e82717978d594f205c5c3e904512cd998522b933763b3f0ae56ee684c1743ca21c86b6f98f5200fe352f3c2bc5641d8146077755332834cfa5ff2663af15ca0b7a239be9b661885be6f39455bb4be1c3b54c2d598683c9731ace5f19ea7ed5c1fa85f8e304a50833bd1a66157c92ba2d91f021400d736e39b05", + "h2": "23356a7ac492a79b204f34ad22f474c3fc03f1254d2a4d24ecb68a670f1cacd6c2d6e9522edeb8d8e58da89587ca88ba878bd2d72ed3ce74104996a937d7a5b8e68b26200671757e110764c16b2ac2671e03c56345cca8bfe43eb514a8c7e1f45d05eeda3b4814ce63ccba37d47756efc7436dc899c4fb85832a10d05e11bd3210bbd0223c19fce9535c0d3dcbd3cc29797fc16a25e5465c400fd0ab9e93dc4c8b3ddc0e736bb5034bb20ebee475d4a837979fe6dac91f967a90405268ab6293498592c15d8c556ca5e893189f20cb4f93618818e19ea2fd29b44cb3bd3afd7641d23eb22151f25f37f6c318531d2df923ed299444883313bda323a591c695fa", + "n_tilde": "bd276406344107286ef49a2acde336f5975dc24bfe350d57501071014b374537099933214fee6277bdb4138a1b5127a2f4417c30c9b271dc03e86896522a1b18d25f545932f91ceb5e037712b1d121012c1649a6d07a6acddb225a6804e58ccd9fc88d5c872ed5912c5f4179747b828a3a9740331b0d4e2157ac88b517c8f7e01dc6475d61d60194c31faaa5ae381c2615d7f1c4abe0a3e544811ecf0d1494461066b354a201a78e40e4f289accdfb15445e1248808a31590d7a70659f2c55721ea4a821610bee961924a3af65a0a601d3809d2bb9e223b94c96b2f2ea926af0c2b88b95dd334cd683f3ed3f5c446e918e9b23d219c8a9f58631cc94aecccfc1", + "pk_n": "ab9acc348c6290f126cf3cb35e29b71cef8cf1c98d21f22276d540efb4f2a74a722d2b2ab6fd3e400621de109fa0c82104a6111d476da33c679fd58d32e32551e1f8e4b39fabd9ff7c6e5bf76aa5b7ba72ca79bb72eb68ad72975a6d1cebd0bec34cf56c9cab4d39f6280206b001d6495b6e1c58f3b050be29e078aab5cc45cc201922715dae7f72bc8810380a38c17b7838e6a18b804e2a25d2d22977fa26dc63161130464af47dd5c42dba70a85a0bfa2e3ca4889abb3cdcbecf75165ef6345ef1e58f9929df65ce9bf33a53e8f1ef18c73231c70f21a30c4c21f10693eba687faaf5de5f3b27e020527539b3a8e8358a929bca06c1ff6c3a2720ee19bbcd1", + "r": "2", + "x": "7", + "y": "b" + }, + "proof": [ + "8bde2880f38ef6936972c0db7817b255eddc0317d80fe600368e2039eaf15738c403dccb82e54dde021058477df8b6f79b160c641a55831043de088be0bd6cafcd6cdc5bb2af89c40fa7bfc45e359dc07f2ee7b9d355fc555762a5e3647dbd4ebe97e33ac754bec7659b9b18beeee9aec42ed433fc0d6efe5b9447ee847a22432fbf5b52b9693937963389de40985b255aeeb5ffbac06cd92ba79dcfa994a183e2d0b53fbaeb01dcd0aa69c82bb34d1e0ee4125198d9cfd5cd1faa4b6af0e3bbb2398e9f1d413b5949fba6ce4044cbaf76a684a1271aa6274fe8e66cc9c7769f7d388f812ea33d036b84e39385d0e9b4c4b5933c78a221ece50e28ae07eebd97", + "7453ef91cebb6e7fb2b7b57bdb60bf5a9f077122ab7073072ced80075e1e6b8c846c2e19738bba47e03ad99ff17cbeb88ef71c30b71999b155e3142f16c35c27973914b6d2e12eff81104b2ba7d8fbb8ae49932b171bf5173e31a8e6dbb1678b9d124bc404fb0939b9ba5e47aac22540b6c185531564d287c2f8c9349c47d893500e57b66bb58e9c189c32dd1d99edb8b7937e2449e1210207077c0a2007aa8ddf7393aab05d6107c10d2bef888e49132023bb05a1d5dbd7f8d9d8af71b0b44e2abbaf17996fa64206f11c80938619b71b26dba7ccc77d9619d94f98df9793b8d75a8d4cce21b94303c82c5fd8265fa54da5354ba756489986eefdfc980530be", + "543ccec0195767b77659baae6f901999cec4039131aaffd53c2bbcfb0ec5e0ba6e3f98c5e67ad0ed66729e66adbad5a9710a8d4d972dc4eb854f571a7985cbf20d1b8aafedc91797ed704e58e2d3322e8c262104f8d368432816bba5adbf0634465391ab8c6ba57dcdda9866313d53a0ee9f67c5afe213ad38e20f70a0efe7a249a96a01d8ea947ce1e1e7fa20c1d34c5ef223ee020343b6497486e4f41f689d2528858ce3faf7e3b37978f25f56adf32714f706d091f9a6a1b92d40e521f257aab96cf949cf3e4e5cf41a9e3de896beef139990d42c6ed8038e64ee690c12e9d30e776feef0c832cff7f3fcc4a1117fbdbc42e2ecb951aaf25656f97aba9099", + "56f6e277b53274933ab2f0ece8cf4dc41debf17b15dbbf3ff1840f9c4a654ce46a8e9568a415244fbf9e624d32e2f2d9136212ebf7d9dc562fa8a4e57228de3fb50939ed252aa38b19402e5e2179bb4d412cc7360341fad6493adcfecf52a481369f7cfa792311805f97660fcc23dbe3e06f8a3b947be9f17c62edc221993f347c1b0192d8a8c7b88dc1eed8f89f68bfa73b11e0b5a6a9b286805aeec9f99b02eea841c41377a295910db3f406bb281c329f97be7075c32ac1b4e5cdfaa5c6c8ba93cd1fcd14d3880d79132f72e2b3b40c5ecb75b81f7192c1439090103c2e5bb0e597da0584ed3d0a86d048b92e7464a06a72f56d9b96cff5a5debee756db30bdfa94b47ce817c80003e8180cdced6fe1f7021cb2abe73c08843eb20037ab8bcd0e4ead7596c782a67b2c21e178ba2eae46f40cb593a0b27f93727b22b1732437ecd7543457825d766814e1dea46f62fda2d5829b7278653d114a1a514ebdb594d20d1f6a531af57d19e2e69c58110e4671fa4be0a788c9d7c0bb8314447b8a90c9f0dfd693ff69e3eaf0a9ca1bf36108b178c2b86141c78eefe4d33dae85d92fb4f3d6b5e169d44806d717128113b2fd7e330e23dcb5e266f9460a022ae9d2d1ddb06793e872719e476c5fd67e243dfb13b4e2f130b735b4b848646ccc2e8bf9f555fc4b76e2e7fba11ab66ab6bb1329b758538e2ebf975f7e41fdabd49858", + "3dbf3f51ac2932435af98c8009ae95cde57426175d97345f116e2f503fb2310008d21c9de7ceb50d075a5273da227a4fa9ac0c05b4818ab6d905e2788e518846b1b5ee6242adcaf11d492f13661037ad3b7901f2b4a453574615685675d9df1d7fa442958a2cf13059fb6833a79df03bd7adaf4853184b958667fd267ced7a4c043356e5f78cd6729726d98fcc4ddcfaf469f7ba6873c4483a9dd41e8ea4bb64cf5bb4f0de004699e4ffa4a19559317968e86227c23eff625f0df3132eeb0383aacec697bd80481e4cd5dd6be7c45a9406eed7caef90cae7ef0618bd6278fc300128da12aa931131687dd38b79f4fc6976cd984f08da2855613a9215ddc74bce", + "540c76c8f333a70079a9d576610fddb49d95059622837103af4579c121753b293a176477ee466ef2d0ed8c1198c1c155e3a25a1f28e741df2edececaef54afc127b6962b06fae3673a9550b35b7ae50c8e383a6f6b7b51475c28105b7784902d61fbd52494303a2d02b3e614cafbbf9fcdf25e1d65ba6f2a333069444fda78c1b17a4190a25e491c4ec66b7c0d19807b2f437de3d82b66a39caa92fcae3a2b8b3d647fb25495b9d61ca7d83360ee0141d7fcd4fc2ab8e315271d6bea6dbefd81d58eee1038ab02a9fc95f6935d7d6af384e9b999f55273d59f3387f511f3ecb807a9ee6c22051dcfa49365f0feec6886ab0674492b4ca27e4a598854ecd4b52b", + "c85c9eeceb80e36d13fe5bb9b45810fcf11b7695071465257dc9b4ca1277802523fe2dbb9d9b757c0ee4b3843466bcfe5fd8ae441aa7acd1d570f2f1f551985da3eb749f2e3f5c8ddafe06dda6b293f612274b00fdfc0117dc30ad0e86f28edf", + "b78f9cdb906a066d6f23f4e0e215c63f1227c639da1bf92ae52c23905a17d572287828a86e0b5d86343138721a10af57b7efc85f44cbb10612ef1982262568a8b30de25cfbdbedbd4bce1c99569e8d331c68def4f2bef7fac43409a6d7af67b4456c1a1dce9b7362e648c1ec44ec7bf6cdf77b68b2732c6a7405d8aae337866f27a939c8f5560177dda9827e165c7e4ab061e00b34c16ea99a05283001c48af776d92ee7740c18a5a74713c92f199b509b50b5ddbd956c37a7b6d179a32da0b38105f958ecb8fd92c54db7215d2448f54ee04665b49589ee2b370e8f14c0f3267628f579c5ea09f64b67f808d55a19ac86b35644e8419580189aa78a33ea1d37dd8c3b4d54cf73a5644a2c868f70b88716042fb6d591abbdc98f3115b700f437d21b37693dc5e21d713ef728b96099f59f0f346e30709c4dd09a0071d7c6dcf2ba544b093ffea7c1367858b6489d3a307e4a83374307e9642cf48f2f16b603b1", + "2c73a565fddbb0af31a5133ac3778c33ad52e95aa4cd1cc61440947e7c705a90d4007f9b595ec5dc4c359d63fe72e78537c1f7aa8f3332bdc888c28d70bbc078ad49de5d2ebcc8efe20b635fa640fbf3ec2ff3f1a4b53dca0eac12fc942afdf1d9e161efb1c23092313d140eca1bb16a214b742395031ad333c42636bb2aca3ca4caf55a7f770260c4c6bd96ae98d970125c8405f056635d8dc1483a378b234d20d7620b5bd6cac08e1c27eddce9e035a04fd5c6a33d61aa1011980887eb23afe08d946aa620c749b702fadede552e533af22d02e18d80b40546b4d1244a341fa824f91cc116bd8d73333924477bd7dee77183f9bff21bf0dc063c9a65e2fdab", + "01e3a2864c0ba5e00e7f1a0c31d6e4f4e3bd3d142dd36ba0aa2a1ba275981d8030dbc370efcfafc1ad428ac24d9f2ac0f072648de7c1285df928f2ed2df152f5b5b9d5b4160a41ef5249db7aa4f5032b7a52458388f026be1eab01a23717003919bd4a3abffb691b81960de67600c3c44d79405072c967e755b5d5c508f794abe2f9464bb44315c2ee1293a0e2bda6aebf8f53b7bc198778452cd1f782e366ce972278df6de9833ea63403ad01cff594e90eadf14b31a07318c2b1f29244bf366cd92ac4e08ebf84a2d28edb5ce05e4cdd5fdc6393a04aedcad78863627c847a428b746a8882c3e2732ee42c8933ef4a66c453a2380ce44da322854b3f822e807ef47bc3da5212ef0ac3c7c251f17d078a6f1511d1ebf1a3dcf2b63e66ce5f618a1398ae8f9db70186ccf7cf02678f16a4496682ced8ea1a68c466c034f3dbfa" + ], + "wc_challenge": "d07249c20acbc5694732d9ece8e8ffd157e02aaf7f2ce553a5e3d7e24a748e31", + "wc_proof": [ + "adb6effad30aa2324d64112297579ceaeb62904e09bfa70b1bf37082d708bc5b24bf457f140a35722ba6facfb1998516bef0250979c3f25b8075b9c7f3333afbd1555b46700fbe57be806f923436232b28042fd6d6606edaf14aa56f170ad47366a25de374656838eca57dae372872f98478cfc85dc7392a01a09ee8208da125b1b003ff25c50f7b88845ce22c1b9295945cf668ca731bdcd499467f42e110cbca7ca5df3cebbc70fd6ef44c9fbb6f014fe17e3cb12b8a47844cdbe0bda2afa3254e2a68180e51377b8b32e53f9b474a1b53d01c67a8543cf987b61cf73f28bc10cc5a41cec32b9ed12f702c43610990c4dc38d18ceadb347543bc7f900bab5a", + "aa54428b6fec326957c711f08f95d084aafd00c57505fdbdea98e5e85871c46a8d94c5d142f140eeb6decedd0a07cce8f040fdebc11a69b910e4cbb510c2475e523b013ececfdaf6b580274f4953e8593d495f60b1713d0168a9091087978aa46af774e76fbc94dc5b52dc35decadfc287c981507529930e1a267c704cbf8c8a55156266255bc3846d0b013f8619c9617e10a9cdd248eafe3ca1d285cd47cf789511f05c4fa77b9d767df001f9df22ab00f65100da86ef17df1e3362e1cf5f8ef0124054884412985411bc3557bea9fe9e4c88778b1641d7b4b28b570655bf1c1acc558455bbc8a51ecf55f6bb24dbb5459510e979d5a7c8c220a5fe6cdbbf41", + "44866883b5a4e4e6a9c150433a197c60dd4e44161593d9bdd87bfe7bf94f0e20aaac4d86c0b08b7a1dd2ba3f87254dc16f6b53d62f971ef441fed37ec4bda5baf98b3b3d3a11c33f37938734a86aee6e1706d6db081fe656ef0c912cc75f6b9b763ce9976fccdb0c3867190023b692d61d753b72f28d8df4f6ed48508628db7792026ac10a0f04cea9251f1410721f42cfd900f7067882afc48b485febdd436b1b639350e27e60be124d9ee180fb2666c9f2b07f5af6efa5fcad79f652fe53fc406809a8c389de78222fb8344bda6d1f773c0debfcf5eba0eedfdcd0622bbcc1d9f076d035d703c61ff2733e80bc5fd9de7fe54757760b7d3593d5412650cfc1", + "46aa39a9c23f8b34d2f831b6524f7e15745f1b3bd660473364b4a00cdb4f44018301ebe692f7991e1dd81df4e329de945b85770f1baaf700e6ee2db0c6953c8944ae9f1634886f19c6a315609ebe58f9fa77e5c57c2cb55485873cba59a3c541688af3e5f1c10d195b443eeb0311f5655056195a6ca8200c65c2a1e09bc6a0db5e82cdb6b35f2d03adfe0d6aee54c58325ec60104422b7bcd5d11c7cc3cabdefa34a53220bca6126e5b34cda21f873a2a2b1694fa24019d077516bce625be444cfa27c06f1e4793a71e913af3a1eafabf5d32526b131f5059165fd30e9fb46cd82de26718824fd86fb39864856e87e2e0a010a3dbed621f1a159ead4a68f31c58786feea7ff174b14a1f9947d81e2d9c2882fc2b1b6e1991b96da3067e59770bd61591c1dcb49ca5c65df455c1cb70a659f5cdd5e9affdbcfb65297701d65a8114105591005eeb189f751e55ea7111efa29cb0ce321f897eb0128c9943c8c806b9ac48da46163a486791b8a566842ef9ec538104b2b1b16aa8f8cd57aaf117e482bfd61d3b55b47c2a4b718a00625163066e2ea1511a917bb2b581c1ddf31a45c401aaee51a90373d59bd12965566208b783e35213052bed73fcb7d7bdeeb68714e331b578a605cadcaa1966c43c8f243401b646c576a8754d6207ffe6b23f5d0d292d61a8c3445c16ef950a1a797a8495798863b2b812d54f5b7da4af65ccbe", + "9f5277eea68182f22a4ce9c86f2aba3e353d9fb1da839b9b3d3c3813875ec9c27c50e962f7beba9d9835974adc99b8e1de93f7ee61b2477a22c11532cc79f857bb28d3105bd60804e5c3a514bbee184a85f2fc7ca301ee46f07e5eb935e29683d4d6533b8e4f8de94ae1522e296ae5877f9c6d4a8355554acfa23b36afcc40c32141651ddc389114251a6e88e1477764670eab10c7c62f9e1b8541f32d7fff9273b9955bacbcc1fc3f5190efc2ba1c93de2fe1b592a73a8c517995f5aee6c0993e3eb2036c9ea1c0cfc7593f313c7d16a61740efbe08e0c275e68e7bcba3b3a297e03d3cd6b1cfa6f33b5f16fc524c27b4644c0c11d424e4d1048b6838bb78d5", + "97297e95b386037e28a2758bbf61edd5a01190d03f65307fcd4a634c5b52495203a5014a694fce47ec83e70e624d0b4286590e237ef019f4a7dfdbb73bdfd5c38345659c21cd96bc6f4677c1c9062df520dea601d5af0427c145dd4e63d1168d4355ed021b8a01354ea3f1cea57e010a1d61c73e19c7de59fcda52a9f536ea0ce18ac935a72f0e5a2058e1b53137000a2df662b27a2b380fa992ebe965df4ebe13df9433116560121f2057cc6bc42d85c25418d636251312a6ba58e0f70412b302386bafb1236d91b8152fd7852e986f9ae5021da74909cc3056129bcac8c63bec25b89cd1e04135154c4f160a7e64221c5fbea148aa3190b0bcae307d566cd3", + "8b50b7f2f99ef6f7731d21c699d5e54b61ed86508e7b20bbe309c693cce4751fad1f15cdfaac86149f8d014ad38d7064e11ca4ebb3126c635fce907b93562d71f13ac54196f5cefd8b063793104102ffa4df0e44d7f154587fd98bc6164b3fd9", + "900f33dfac66fc4f3152eebcd4fe5ed1ed605c83cad51dbd43cea633b4f09739c0f181b75fa7251b74b0940d9c34732d09059e2f0aec01992fb10106a8dd09fbd82296d9fefdab8cec51b6aebfa8736436aca720d46299c4404c0a97d36ab46eda750f3ad90e2b1c936ed48ec09ca5539727e40c6ce593bc0f17a4ac4b319d98e9ea86e57f8483b77be3eef5e806f886ba2c5c83cdd8742644428cbe05f1638dbe6f3e133e4400caf54d0969e697edd92e1f1705ebb54841a0700783ae1cdb60f2d0f279fb44963c937c500843268d30f8339d05fb3c967bc5941719ca66b164c718008e7a9bacf16412b47e7694ef8ed5c48ce2bfbb1fbed5c5008ae6cb4af614e5de88beaffcd5e3ef7ac7be6012545f1f622820c08fe5eb630fa4fb8ab85f44e5b14c808a00d33a003e983880f111cbb53ff0a1d1bbab4d0e0e129e564c256f396b9f263116510101682644b4e28334f843c7c92b11b691512ada2c83a7d7", + "4732082fcb43a109070f4c3532c1806c31bdd1ddf34a1e8dca36ad4121ae91ee757cfdf6442a73560b0ec5745a174dabecb74fc84ed9b3d5677ae209e69d7c834a47126ba8aa96e222080d546a9db191785880d25497590de2e74784ce62c364b40caf6b3535378d5440b38f94e9d09831c23762cc878c9ff56fffe825869c4a686af1672a707aa7e59612e389cf5780b7356a7321ad98a44d52f2be85dc3e713359e47339bbd60c6beebdc643010d785116d19b479b4cba4166761019e5647fc32f759c2d1f6c4b6c24b72e868f9281893b11690342e51dc961132502f07dd6862a8eed413b92ba34225014e9556606502d4356720a2ddcc0c2ef8410066f5c", + "93cb7a255c12a952fd8d671fe3359dbd637dbca5d572e43b9755a07c26924e4d6afe85a18fd3dfb886703d2ee086f6e613cbbb001e27dacab63b71db0f91b0ab76acb50e7766d0c99eb0a89ca7257375a4b066b3819ad2a2a30038539e678bafa773662f44771857aa25af0e1003fc6773dcac08c76beccd81159b8ae9f5ba3b570d0a433b450f8a605f93b058edcb4fdf5eb739bbfa51266b2fb27823000f3a402158b9016ab122da57d3930b33e8cb0220930b3c321190bf7dd943db6e7b315892dc04fc1e7a7c43e8e26f7d591b47b2089f04b85265fccecb0e5e80f44e64cafd343177106678f61741f98634f0ff04e5cb19afec778ace97fd691e8481f95e6f64dcf810cb076dcaaa847ed1459233909a285b8d48df65ec3d223cb04050c232eb386e9155cfbffd4b933c960ad9180dc40993ad327b746f6194d0756ce0", + "308130dfb1a5af51c49d3c4501abe5597fc8d71be8d5b3250a7eb02c07404080", + "3b21188060d87440d4df44eef99739ab37c7fddfe05a2dcb4baab8eec71c41f7" + ], + "wc_x": [ + "5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc", + "6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da" + ], + "wire": "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" + }, + "curve": "secp256k1", + "dln": { + "alpha": [ + "9f4ed060c2f28ce0131d66cf9fe18156b3af2f39eff9dd68951b5ebbfe7098467a25634d9ff93d62f6d12d088afbef975be74f4996badee7f7ce8cc87133a86ff1eb57070d1fa7f209dd7afd91caa66346ca9eeabce3d62f087be8b5151255da7049345579a5df84c2ec76ab940d10f26a4a84b36a7f8527592a6fd0c05b6ad650de4474f5c756fa182c2d912e3cec0a7c83b2f46e56eba1e2bf4cd1ccfcc92232f7b7705e9998ba4d49e06b5564d9382f410d0f48988208356a67c983dcb50ef8c6bb4d52846223aa057637fdc0f462ebc7ce0831c78aae471a7bd55f32d773b106b0a342f83b018f56f13cf406c4b43759fc502b54d62da6eff035ba275830", + "66885d76eff62b8c7fa2160d49705be9d1f3312f49aa021fc8c76814c88623cd67e1211474574a90a0940be8491340134a0b5c613fcc23c3bc7fd84a7d190299ae94b9e0bf092b98b0f43e550c93f5a35406b2646f0e3d344b9e822bbe3231caf857b1171ff1a83ac2761ce6175645359011237002a798da147e2180328f5bc5b5915bbe2a17d5ad6277272d831020f19f4523c7504385a7e70127439b5b476aa45550072da95ca2b8f581fb4e1767ea09ad65b59582dc056f84b2f23f3f129ee1047fa6e431b3756ae7e065abd9aa6be118923e0c64f73cdb6cdd34ddb96d9e07034288aca3f3f5dbe6f0b91200e2af82952121a469b09dafed29992fdec85d", + "36206638dab487f7868adb46aa1da6891fb36cdf8dae1427436ae6e4ed620f438140dfddaca85a0866c879745b153ca0a48a31ff9bedc514ba5ad4cf6086ba2c0f2f8a07cefdcaa5ebd0a10423b2ae74181f4f7907b80fdaf82c40ebe76a2c2a304a1662a5837a94e78ac1237bee4269d6e11cde34ef6801f2dcfe87a9e65ee2109e57b0fe0b6ef9e7dff6b878a62d2ff0f29f38ac2d3d63570682cc88a95223d37d0ce37a9ef0fa32f3162190e9b7fe84d78108c6be8d04a728d0c33583864e23aa164295a3cdad032d757a237c88f6caf2795351f302f8f807b32e0f95f1f6172cb2692bfc2199fd063b9ae4978a453b82584ab65dbbeb173dbc782b34d033", + "4a3c65defcef776c7c16a7491a1efc491282f7e3a6a9daded0b62e28237782dc793ef70a7e538d07dac1bfa6e4276f565b266c5ec725f6d181f336dc3d27abeac6d6053ec595827171e14576e137887d6378faf9d96212b9718d16126f1f0f03899e23eb0cc5b55b3cc994da3dba1399acada0a122f5cf23c2a9f7ffaf775bc607e07a0b077526c2d422a9e803518187cd82f664cb241c6be278ae933820573e0249fe484b94f7f5c880100a8736dd0935931efad94c20d1a565de3ff84bc87829b64ac113c8d31ae0cb8c4fd7a40941cf6def34a70933f05f31cc8a08ce6f3125c46ab4485e04a39303b126bb786d7dc69b8b55a50d401d4e0c412b0e236f02", + "94b1231b3194c6db0a3524af665b1763574f82b7e511b814104e3ae06b64e828930d7cd6fe83bdaa47977a93a52c018169d22d9bb36320f750ccde2dfd77de5e044c831e3397107e13ba0cb0ec26efc8a4846c20db1d602f86341271a435c23338ce3f71db6c59030f4e446ae9ada4299c0677e303bbd9241f1ed43e9b0a4f76f56b44ed4584bf70b0ae4b3abb87be4d49ab029feeea823594a7c4ae323428000f08b2c70bf67ebc13ba895c0330fb01e4218b8b827b31fee4ca6d0f5cf35d8d562df4c44c3b731b5823cda7f461c7e1914d1c60e650dc900a422540b547aff3f71b837c7d10f71ad343c3a1295bf40948d0dbbd3561eca0bdd88f8e35752275", + "897c580fe218187e8088e090d1cf3c3c771d14013ffb6ae96e9410e434b335cf6d500734ff93671be93b001472309dfe6161400e39d35aee618682a219070fdfd2f0011dea8b9b2e4872d0c4a4e9265eebd3fd3932c83632b57e1fab618fd233c071bfeba7757e58ff9161a34bff354520130b3fa071cf6a21da7141d7772b41a80fc16c14c2544c236fc771a16bbd0a852185f76f96094f0e8d409fdac624bf2a4a59a1f30c3fe7874889be1e3f95217ad85e1f5afed35d35d055e027c7149a6d903e9da77963b408b95f799441b736a785891c620ae28b7217854a306f116732b3d0512621d640fc6ad45febf8edf194b290b332f45db3455c49dce244c45d", + "18ac45aa28882ba28577428bdb23599899a59dcc806add2a3c06d36e5ef8ee950f3accb85211d06537b6df5e9a79e146079cca55ab7fc11cb152c5aad5831627ce7f96520059f08ddb0c8f7995b02ad6df64944cc99a24eed9afbfbf7d9fe28502398aff9490c161affd285469afde3815f39027998e401db219d0b96f24424cc538473be2c4af16cae7188a494edb9c2781fdc8691cefdcab73af7c536d22cbac494b88ebe18b26bb2097f9cfff78e1657625f9ffb5cc772ee703365cb3d8e0447af5742536ab99726936939fae57e62ed5d480caf25b2742c84d43481352015603f8f38a4a1746b2094b921de172460387ab0bbcb1ec6b451b59164ab2b580", + "80d38b812ec9f23683a93df90654eda0a4aa1e49c1816026e8363292738b180e247ef54085b02f772b31c41b422db220fc7e99312ea4ac09f1e030cdf731cae86215777b7b98f689505f851e322bf200d691466bdc60414a07358cb4147149e59c4a467f8585c0825089905339955a01aaa67b7ce0f31191ca533faf610ceba1face6833b56e9bb70f91bd7466a9d03dd2db6e634d35cdd9519fdf7c431101d746de7e6744e39be7cd41b7def33d2d51a77799657d3c46462ea2b5991b346576712ce1dd900857897f00d7e974aec29176b34a7d71430f7b99b82de87f8d6a3c00f2dd1f5b1986ed19d0c3b4d7733cede0c8ecb577fa39069c40b3956563e3be", + "bafba45f16efffce33df2f7a3624f4ddb4af45ff883efff9b56b5f2e2d2210cec997727067a67b25244aaed77d254cf4173d2a8c3e5eef251cbb011a9e5d6a9db232e7ceb048913499a71346af3a82b9ef220e9cf0fa37ffb42e11a9653c3d3d985c6db6d4e2918040fa4d3ce5925e06da2dec7492c938e59cbcb3495b8ced9e8155ff3d9bd3143491f7fe1a80bb7b077010738b21e8acdd142cc3e980ba521b0b61e0869b18cd463f33ee8ac10b92118f8ea2a8ce2d78b2417ad6aae6887338e3200649e96eaa4fc5bc43998a1000f4e7204f58eb1296447f1835e4187800eae3bcdc64fded4f57380648d719896ebb1349059a52cee2fafb02135741055ac6", + "7939227a2fe827d342f49afc3431fb3424d3ed614dfcb4bd5834f701e3ff61b4c552059ed0ed05e2f416f6db612835c4d9ddc08c4b21d6c2f2c0e0cc0244be3896d45a9ad1f2486f36c4c60b3be148fb5bb0ed59865ef39037d66e386d0f4a8524b7c137ad23992eb534918302ad118b67a130bef00fa56ea4a554bd855be51f5957084c42b12495a7ecc5c9ee9140a6bdfbf813cdc30684d953f377f7c4965d4de187e6bd4152dda490ce7862762561fbb05bf73e777c002ca0b17701f6205edf37ec2aa75529b7a360c3d6ff4dc5330bd638d4047649bb0c03b660ed30deb3f47f03b7541242cb515964aa7704032c6f4e7826a8fe4c6f3e4a7a1d2a98a87b", + "37fa790f8c4a359dbfd9bcec49840af23870c267919ebb09b5e4beecbb30b89179b01a764d10838066f8580c6419e2aacb7ddb57908b697686c6dd12cf2e5e7782e00948e7bed2fdd5f18205c0e10317189189abf16fe27e465229e6611dafe6b2ddc2596a52cd9a0393b814416f730f6a0c12d26bdcbf6aea18cf8b53198d336289eab189909fadfb130a64a96dbfbf68cd2a372adc19c54a641f494c982df22d53704a0e65ec81e05d7e6d0c7cdd56d34e142b6d035bd7eb59cd8b2f37dbaab93b72ab4a87be66876a8b46ab346dead679dd26cf3b4dd498cb8b6add55700f2667eed6647272876a4acc47679b23bda7d2acfa2dfc0cedd4234d13f0fd7d65", + "c278be3656ab41ce348ce4fbb549abbaf088f179994f90ff81d3ba25b2308a90a187242f184dc5c79f5a3a6d2813e76bcb23f7895d28271db1ad89a5477bc7e73631ca5e0cb7de929f8c3eff03590cea732f3c2553319ee1d6a62b87c48949c8646da75973074cd14e6458c9ebfaff7d3e4b9493c12ff7b320c43cd7b35cbf4da2a229c1e639810b90c1ded820817338e945974804cb2703de4cb02ec979c093b9b67bfc01688727eb6be651f2e2480804648d2a0f34aabd793cb267196176a74e8541b4b07f2ff39c68b325de2d28bd397165009ac498f6b980fd2ede06df2ba721d94270090465b2824e0a1ed6c800ec47831c1454e2f38005e83b75b371b9", + "31296d5bf39ca9b895fe2e4ee658756d8f08f8bab5644b1124983a151133469cb2f7bef79f75ac47e9f4d73a4b0a1da8a88882062d4594e80804947866b0d2fca587ab5047e9f95205f9a7ed5968e3e685cb9a663e9a5f9597b92b156fba34b89c0f41d77cc090dba27442f194d2319986f581eea1e1f2b4ec769a6fa8ffadb911ac0fcfda809495171184ee225ac8753c3c2336e4f07a529ba89471abe1dca8125a73e880e3e79a30882b313cb69a1ebb6dee4bfad3a82a16a78d4f52460d3a93fdff7d2efeafefcb5232954dfcdec26e07b018b23bebcebabcc2bf56c8d114ed136ade8869428e8554930da8464d1d06038f09c5f4d34376b51eb8dec6f3e1", + "85b2cfc4c5c708cd90f749a645fd48ab46020b7fed00cc26108ccf09bb625d825787a6672048f748630f4a495b7add68dba350c1a17c852c8c61797135eeac9cf9526c5631e9ec69d179f9781dded8f4d78ab81dd423835d28bda77bfc309166ac32abc7f268c0ea4aa0a65ca48c7497847cee4fc40007df5c4c54a06e0890a2d21796d32eac5436996afaf4d8615a4b9ce9e4d8d5cd60809e050feefd307c07c2ddc94a97801d908416d561fa93e26491788916193e84a41b24a79ba6040626ca7dbdb98e67e5db0b5148115e64f367da97ee4db5f48db7384ed44d674cfa32ce693fc29d416d7b4e557dc8dc0586193f16fb74b03a29936c107e916eff4518", + "7de3f70faa5a2ff96e944dc5a68faef2dfaedb522d5f8e10abf14bd2511dc4e8f94f7f26723706287bbf2c941dbdc80a116b1085cbb17fc2c3f2ef6e39d002f6672eead02612053972ba1044ef472360f48b0833cd3b1a3db7a3fb0171f091c04a41c956e78e1fa0273a902fc42c26d3db0245cea99ad3ddea03c73fc13b827e07675979cc45080c82726808ef38f64e8bd92d299ec6d9fb5f30f0d991d2119fbf33b3942aeabe9e049ee46f41b723ed0dc4f07710d9f35823227cbaa541c5c2c44201a180397a4bd1a632bb87bba6fa2893ec034188e6e79ce11f8dd5be3e28ccd8275e38c55dda4e70fa91be4b67b094bc3ec05f3085e297a5684000a31984", + "a99504e780d0c8113d7ce102d98f5107c8bfbc4a2a67936980ef53f085b7878c0e0ddbdf3254e58d9345645c9b50c09e0cd6ec6f3dcf24f1f9f67c97e04c8eecff73b4a79d9cfe945df798a80d4c518e092a9727b92b85445dae5240b6d358a7754981ba37e45733aa0d3abc15577560483b90ba507f88daae192d1f48e379026b15c59978b59ce963d0b5261aba25cca74b0b21f88b1e0485ba91c252c9e11f215f3cee0d34cfc206577888372c6b155f50bfdf4a4a851c3e7598076a3ca2d6ae53aed31b164c8c88a2718d586a8ffae619abca4e641c82050bc4e5e4b30d736a1107337c7164f39e4c6c9973ccab7f6b1e2fe0e72ada790da32206630ec6dd", + "1c13701ef521792e207675cfa124cdad36030bda5a6d8fe3c1a0ba34c0e674c795fdef291ab804cb2eb8aa6119169ed9667611e6c2635991955001799e39b970417a771320ac1d9eb5416768c91340d4aafb9d08230837dcc27af8e3e6d26ad9d74c6a066f1fbc502141a2bb389ac730fc6e6821792046a7f17c035da78c1b65d8d034894a8e7c6322ce98a975aad09d6c0f232d1a0c31ceb3469d745db21946007dbce19a26cccfc0071f78d20af8a333e36d72ce1469d75dcb3802d3248d70bc89db9d97da55fd3f1c3f4f0693539182b01e9e5cfd677569146767117385d3de97b8131dd27c5115502eea2c560cd1c1417fec0facc03b926c80387ca3f931", + "173549ed0b1ccd788283eec7b6373bacac1f6d52a0b7ae1979c175f8e0e905f2112e0a06ac76751748ae50f5ddc8ee1e10c54f91003de1c05699d74d39e4d83bcea9fba9494372c8b46fefaaa67c683eee2021d35a089ad853ede5b36a498b97fa0e17e29b6fe889672fb5c7f8b4733b17aad05746da0787a31e3524d0e5ac0d176974613bd502073bdc0735790cfc2fd561136a2ef5b7fd9c1ebbe47f02c150ac433c5c8d48d44115a5726446f572a65327cbd19fad010f409528f79e8c6135110f9ba2d7e219db51538f0e1d08fcb5fa55dc6bdd3c0c632f98c2474b80a220616873e338c1949c10fb68ac817fea7d7845b86c4c5acc1141d1c4bea459b5e9", + "d88e1a3abc16081130db01e6e5bce502549701c03530c12d069a951c4683232674d4db26fd52341ce466a814cc6d4e4c09214e05a8c2d165ee4813c793d00afa0db6c6a9b53bd63b142925b94a12864046cccc817e205f79ef4f93f6d60c43d5b48923f9398383ed590ee84b5f64bd638c9cd19d3b568423bd56b036d090e42306aef83f920ec3da13f81f4793e33bfad1b8b01d53b2418856f51679a03dc83df9d20c573f9d224510765690631e0b7d3b21e7da7fcf5d07f7d6e222f205fb698757db581e99c0dd456da884a661d69a6e4a0006297b3e31072cb19af0c33ab71b99db523ed7b3475d82eaeed2eb4de6e87279551ec8e68a714ee13e4a361697", + "986d407a02cc3db6ed0569a6ede8b46e7ca6eecac3c22f6181ee66216ad95904bf2c02a22bf347f0a99637926db4d81cd4d7374194ae7402f237101bccbc6267578101b2108b3e7c2cf72462ba740b3f48d681bd0aa2e08eeadd0538371ac5ad32266bc1bcbab94082ad9c7717156ef693864218abb39e73807fdf239565138ffea0c2c8082431b19826812c4e9374083d22becf8ab4682f05df632671f28800684cff912381edefe45a5d2111874fda96762c0fb12870d2dae219a1786e9f4b3a5a32c611ec913a8abc514e10f8fb280583a573a784c7b063ec209f031b7d24252fec86c05eab0c01b728c26ba484322342d9fdc383f45eb20281282abddd04", + "1c6a42552e69789cba2db4fc848ed5e2ae9a8f01bfca8806acab5e9177c1c399b475e0e86ccf4494515381f593d4d2c5f377d25fea2c70c6cbc7e98cb2708c9bea0b546feef9932737d163172fe65f9e288523ddec88ddecad62f77df06022f22759d672ce8bd1726d83c1246c5890499e4ae7d890b68d5310896fc313ffbdede2e6845f6afa9127d9e6045cc95dd3a117473a546c04f3b181608b50a2dbb74727fd0004db198132c84e24068357de4a30d1f25653d178b01d16b51e238d4ba05f90abb5388af14bc1f72d9c8b5acd0f130743d3931f626f64e6411a04da8667683e7cbe9ae6c4411df1e5056621d02fbf72cfdec4b3da1b58d37cf5130bf1e2", + "93ab843731d858cbe8216f252af570513961cc8f10ed49073c7376e64d25cd0232fa08a53d0e61d16781d51f26505975277df0711b4936cf308845b6b9e5c4254e21f3b4023d2274dea249a8428c3eb77ec355c12582441dbde42e0c7d6f5d0bbac66a13091203fa5d6bdcfaa02f77d68ceb478e141d0a78ebd917fa2a698908c713c9f03dc8e7ea01d40da46089ed589052171d7695830c280fc4a99cd911e49db9613c9d5144279ea2e500a80b667a9dc8a6fccce8913298b8e3ecd259b30987a2d4740e643f4926887abf0c03d803c890d12b5779f5f7a37cf6bc6fea179bee1badda6199e707ffb63c0679734fcaf9753c4769fcf1a7dc69cbc71dc321a7", + "a096fd54a6349584cbdf2ca314792e76bf8af59efc90770a684ecf6e42d6f1741f0bb8e1eef87819395862b2385b0edf98afc6c261d3904e9b8e6359dfacfb24eca0105f8db3b5d261ddc64eea1b78a5b994b28c2062071f9525bf0ba07a1288566c4b1ebf876e8f5d3e8a34aee9dce8ed86cde3c97f5aabf4a0f0daa204fcb39c5d8aea29e93203aa276ae99e6292870757598f2bc342386a426eb4e6e7a26bed1147074751f63de1d475b6c8fcda4c4f049c695d634fe7027e4a5ea30329f67ece7244dad99949cca35cd99f8e3eae93b32a1fe7f976257ae428a3c3e20cc81a8eaee3e1e316211345c63b18304f32770036aa01f5e4f5803cd2b5a8533016", + "3cfc801f8f0a5aaccef9ce0d5283c6d368cde02833ecbc06ada85a60d01bfd4ae466cb49f07cbd6ca162b5c52be83f361a79a1e21f8c8ec6fd60fc788a656bbd4b1511f15f6fbb87266089b7e48b08da361dcb51f5b25bf3026b467c851ccc50f715afa9733557f3d2286a59745e4a3640ec15da5c9b1c67ea2cf8f236e83f953db68193cb70238a5bfafdf8999f516ef3b654cc403670d17560d8111d739e43c13c70e9a34d5380df46f2dae52b589daab025a78c292e1e856d5a183df4fdbab2154ffa2a582f6098139fe27bb940aaa9bdb0241254b7b0b7c6ff44272e8426edbebb694bb6d6e77c578aa0b68b46eca29f2f43403e2e9907c3019a354451e6", + "ba26268dad4d97f14b36dc6c8da595c727c9001adc4fbafb1d24f78adccb5609135133c48dc5f4e14755a2506b4169ec7be5bc17649ba50ed17f8e2199d467f8b8c80269e8e16095fc7e616b480caf6da697cf2a7e019318a3742298d6e4ec33ba3a8c5cf79865d2a58508581404eef48559cec7299c20d0554c65409604a66aa3de72263895d14600cda9215a2afb4a856181f0b0d654a8d2f37c7b4eb4c4f82bec1ef742917004e893d53463bee8ed949667f5bf95a55c55e7fc2ac1291b19fb8ca5785d7a9084e61cbd4e8ea4bd77c13509ec152553016faa6899c4ed2e6349465c5ffdf0ae2efdc9e3d3cc552d2b16391f6ef46de811782cf2f2e13e7128", + "532d414b271845a9e8f10ab8827ad28498c243aacb9bdf2e597e09718de180fd08860ae6f2cd300d72d01faf3247e7d604bbdc856310f4d5563047364328714dab87071b5441ad33851ed61da1470c60ed1a92e6cdcac58209444dff1dd39216261103d6cf5922445455d22c71c86a5618930debc903e73dfad71bd75225c068586cc3a14061b1ac47fc05fdb6d3c0646ae804df35f3abcd022acd1e8c3ac31957930d69464a8ea5e596cad0444876a36c49e655749cf1e95d8ff6cc577dc5f8c65bcfc7d119242756f1b270210070684de4e8d09cb39d4525d7b11c06b74f99388157d4f8cb4f930c77c31ca4718f98d65bcd21db1c98d7e6820e7d4779aac5", + "7bc4e234ed10714b3dcb232a3def45a206334bf0d93aa220c50cf7ba8edef81d2c618e4e4d14ecbc7b3bf8af83690946338ac05833a2ec4543d2749c26dfa0b74d9c9ac6ade68db8696dd7d511766c98d7637d53cdce10ec36c92cd3a991eb7c3e558e602b6471335de3dd6075d0e8c5b4706e022ea9663725fd0573099b501f750808b2c2c6c4a8a4b5c461e55bf14da3ccbada4923016c3b6cb750288cc17fd225ca741bc50a7a3ff3144a7fe47450f569658553dc510d9b0c9e379e9a015c2cacf90ff4458f3ef73ba1d883c544c1c6a713f70da1622c19146100f7deddb57ce2ac82f02a992b43fdc412b60d8c6523efc552bda4a25853a0fad0e4fd5503", + "841839578d7a7b7109935ca0f45837a921bf1a1e9a829ec0edc144d8d9c92a045bd8220dd5044307b814519acbb88eef90c64bd7b3527231cf223310bf58f866ef73dbf5f2e77dbbcca5e522fe72aede855cd677d4fe035d522d41dc9da3c1db4fd2976e3363d5efe7742a25b872a12c8230d8cfa1336074ab4016fa0960f65d9541ec7448550af7b125addf95bea1e53a26168fa613dc951a03988047e14bb7c95bc8513a81c6b2b46bf524b93612d98780091ddbe88fcda9b477788332a7982a0dc6ba8216b2958e00b3cca79797494fafbe2dd54c9416d9be4fa80283408fe4371148a297f16985c9ac22be4758eca48e5869aff769029a10886da6ab2145", + "c75075d19a4563b826aceb1d87f878d85d002db36d5b39c384467d0cbaf7cad39dc2ddb1785721db0101fddad5334569e3f3a585f7975cd60c3e647cfd074088411f50615fe15ea759ec0d58d0c51aafcbbcf6d0885ffc60519a63298e0961cdf9e9ec4fc495c04c31a87c44acd5ff766330a47fe370310320e92fe51a5e805f262e244b80966bb18cc2100baf634a9ab7ddd95f4332a1ce4596552126ce4d700861713dfd1a078a3e0abdce051e33c6356f9b4d0434921b52a12890f2c2b0308d6241605cb24676b447ba65ab8cafc46a45628f1aade26c09a8d6b73510abd2184a1ebcd5a9a4bbbfa71e213dc47136e791c5c19199573352cd7b3b4799af68", + "7eb7b038a9c4d2a9b7d9e8201061043749426fa380a1e15ba7ba7f9e61df2f732fda3ef062d040865f912089a66a64f3e0f589a5d11237677b0350304c5c98d2f4289b595fa41058e8233fc9ab4a8328fec712dd136688adbc549a31d78c31afc79cce53969f261a68b6ca02a3a0ecfff9ca7e386ba9ccad146062278a06c04fc9587610f17acc2490434fe1f8e987a23279cdfd2a44bc0cb0cb0bd8c528fd47e830d50ad3fac40408bd8ad447e3a76a8659df0ba6b6827475ac46e705572b28ce687fa9903c8e131680dcf1e83647b5f5ff4a9f4c01e082308b55038b4f4f9b2703e756277ac0016b83026c02ad6871795e0aeead5ad08eb9ab1149514352f9", + "1553dd341fd828f6245c5a0de9cd5526ccd0289cb5087c5918f8dffc0aeb65e9adf57880cef2f1397521d68e417198d5b71b01328f6e8b35267cb008e8d4b0931bcd10f5f682197beae30e79e7efe259db3f2316e304769d67fe2d09b93ff1f00b1b2860e10126efe0e57627717580d290e3da8bbe25e80f24f6e1ce2ab95cc8a8f32120abd897fd081749d1b67ae52c222905f332cc11a4e7129d522dae3ca135d8ed2076d6522fd809c9e52bfdeb06cf1fb30c3405ed84eaadf2ba90e93cc7f80d0dc67a332e2f924b229e3db3db8002d886b12450766268633d68d4f8866e60bc0f8da705101d7734c4986cac19df0a148e992a8ee65efeb4d3340fb35fe0", + "6d99dbe49b31fff12a4eda7c28ce55f9521b65ddfdd0f1f8eea7c0a16ac3c488f70c07204aca042ae82aad3a8772d283e7095790dbf7d29ca7a77cc085a7032f00d9512a82c0aac99dac02648b0a90e800d849b425b93b26c7d63723690c6f2b79ffd4176384ee207a79fd4e9a9ab1afde6283f8c5ee6c97d0ec6185a73895e3e9b76540dc5cc72f4946780f70fbb27b11a8bb89f958a006254a9ce2234644f7b5c3e7047937a9505c477ad732b756d79db2d4cf94a0fc130b6ceee7627e7c2c956fcfcd1d8d857cde3151e2def67df1372c886c8633071a523581955ced9c2f40e061e49b1ca7f8c6c39b88ccd4909cd458a54688d15dd31aa8a2927e55517", + "549feb85d76c9c9c5fe2e3aac729472555d4e1179d3d83e69ee3bd0538204cdb9b7955047df593ae58ff8d5e9fee3f31e4e066752347a9bdbdab9e6ecadd6fcbb879071092f85ad306f03015bf0a0d22e80dea0539b70cc1f4391973f786daee48c0bbfe17b0de7af78a9d1d20095151794da85542fb6c6353465e3c3a71266ce3c592e6ee04720d979f6da6690904329410e7fc0adc5c94c7411595d057502afeeef683f29a171029472d726915c6d5e18cb69fa2a0d20c3e9b80f21254b0c9a3bd5e31e6e10f28f37ac0dd6d3bb681e5c3d0a5c4265bb05bede0d3044cde3e3b75ee4078f616c5975009608bcb915b3b21a1c1ee9d59cae81ec0bf23f7eeb", + "ca530635d30e34e0c25911009625b537aee5b8f85e9b7b831174102fe597cdec3cdd058b4c6c0d955676e2526de1cb01722293ac426d9f5207ce8917ce78fdd507505d68abe3ae5081647ba520a104359b3748a3246a1fe010911dfcc23da07c7ac87b8c70d752ab32e77c06907aaceeffb6faf66712ba02f12ebe43b9afab53568aa151eca87a8f5175c71a810086da134632d35796d2052c8b1700e8c5420f4b1abbf85ba982608d90fa4050bafbba645571ea04d2b21e86df73feceaf1bd4ceedee4132cce5e2d466802a98c58ef6455f6b8efeaf262f622254fe9ca08ccfe631b05bfbafd89c28eeb4e812ff84cf70cf943875e493cf72627cb5d0cfa4e3", + "39c366dd392949e433f361966094b1ae10f042496ab0a6b261c536c69e253e44010ec75d25d94a50c91d4fc9471326d77b318528345c9b695ebf7b84b0d95189fb7b7223c1859973e59b381db8a8f892642a5461e0852f92dabe030d566cfc1a49b42de97b4d78b7f2da9196f593d533298324f617e1c69f2e5c87ae974c25135af0ba33740236142621deafa7794ba8d327fb5e305a7f87d0f1e6de06135347a76fae736e9b717ee50c43b536542ab0ed4ac967cffb720fddd91746c9f5768af1e103bfd476d9f84003d3dd475b425366331720e43cc4a216fd33b511da526d46bafd3ce7f7d936ce5cb1026040314241c4fd2a4a9bae3d5b3a3ca51ce15619", + "2aaadc3f21ab993b4302fa2e7c90c0e729298c066a450f5321e1a83f9032456add34e0dc77ecbef7b5445f0a9b5e683bd96938119bacb841141bbc62052c82bd85f8cbc95e76a98596a5b6b52feead0da98ae3759214341c34260aee4b6cd9fa74c9062e6ca409ebf8151aa43eae09477c2ab51083b42b41f1e9da713db7e359be8a998f62ab4b801f37293374f13bb653a32327493a80ce4279c9eb444a0466e8906cfd9cfe83f9df4d6f8aa87161ad5c2103ea59939d09fa12884b5db8c5437700ed303939c5ccc7c7edfe8f89e18b9b9212ec4d22d1d8dce6ce9b95c95c9ff92f1ecc63bb412738bf2dd6c456810e66a742889011ef1cb99a19f2ea7018ab", + "1d85bc1e9894409c49bd2e3a77d36d589555e167770334faec40ab07623fa9972732800cb354cf1ea50f333b655d576649efdb2fa46d2912f7ff4fae8b8655bcdcebf0d9a02abf893bf805f5dca248a36b7cd84c261eb0fb76f1ef3b81476fb4fc63c31d51d863ed1a8bef6a5858645540d5bca9885c0bff3ece13adbb58bbfb99e3c13b20577abcb4bb636a4d7c6444f1a53d05139c9fa9eab2fd1896a5f2931e1d513ba3cf31387e3ede0cf25963e583d1450c02a0086d8518cac3b8eab5745ba03ea80f1d286157f03094f9810b58c7ca72975db213d163bd95da390d70e84631ecd15e8d82dfa998b27609d825070ff046e111055c56976ee37684bd67bb", + "98e67791047de49e8f4c36624affc1e4cf1ee6367b3efb4137ac8390e256886811502bbf68f2bfbe378af6f7ab879cc7f1d445eada783a191a29fca2357ec3d5195af91d37fdcacce18d87d6bc8387d42b9479694c3614651d3571cd286ca4ffd4ae55e1e7d5d3a1c6ca79cccf6c636afd905d8c88f3640e29fc05b963c0ba95b9c709b4d6dea7e1c04070bcc0581bc4cc2eedd4f68b860453afc54dd8560a66b1671d093e9bec2a308b9af2bc097c0585b8bdafeaa36c18c07c77bb68f329e4e807830d951ca5fd8689fc2db5548ba6d29266d344d5374a3a19c8a0ac1b0ea3c4c1d0a604003cab8276f29a66c1a5a260f9cd444502a2a9e887bac3face8e09", + "d37270191d578bfa8a2e632dd1991cf47093d2a0a86d724944a3b5c970b2cdc050bae30f697b1d20ad9a3ef1a35f3c50c6e4236fc4b0d915284eff8f67c96abf973c20c714bbf5b90d2fee6e0d394220961abf7ec112b4751cdb14c3428187fa3509b98a2cc3710e23d6a24e47ff4766b9e498cb74ea0d30eba62d46a44f0de75d11185a7fec65331b3dd815f4a8c3fb973dab09ac9bff2c90386a4b7b38c6f8d4815d62953ca091b41ce49973d2c8a530facf69ae8cecbdf621a9560f39efa58b65e2d631c19522649703d9ce99a49683914b8a3e3169d79f38d590a0a67a4dc36ea07031e07851318e0e54700f0f88f09c8a16e9cacc4ae4d09276bb691979", + "b523c5e7470147a96d966ef8d85f4896fa1153433cdcb5e62313a11eaccf1a5030f53e4e1bf6975a99d00b46bd09a332031ab9054420230237319ab78f616d4211e81bff9eab4eeb0f0830128440ee50b26b5b9637a268d8862b1e5da9106f2733b6af1470fac3a0b61e3262c60f9c9256a8dedc27379614187d5bb4a9d88cfa2902b19023c065d3c17d5d4cf94787b0de1e10ae092e9859add97290d407384dde961d9757b30e86d8170c3e00da8dfd761fdce4a4756e5e703494cb473681347f56e9302dd0102c99bb690686b957e070318cf5936c1bc5b8d8de7e5b8cdb54cb780acfefd09cb32042a0d593ef1af2cbe2d05eb5c0c852a5e5405a7388c192", + "cf7cc07551f3520df9f3b9095636dc7f344ed840c7195be2ba93b1728e4085c0f3b71a5a2576ba97a8e9309b68d2f3a0a1a97a97a6658322d8164c2ee0df3bb3b379939751f481b19f46bfb0372b2ecf05eb485393e23e965f8ebda7420cab3d352e99ac236c919916163e4d6414dddf69702c5f307e906219e8f64505029f587ac605485060c0d16d8cb15d14a5734f119d81d118fd6b21f1a280d4407d07d55030b7a8ec5014d082dca040858a9cd957261f715dfd848d6745aa5efdc6f62db1cc4ef682de5d9ea237145394aab24bd1fd31a0b80a431ea0d8d8c8307b5c4bf64330f18b2296673f05371227468deee83762507d4bce0c8c9b8789f55ec1b", + "811b46122f6e6e2e3fef5000c991e4fd7342c260cdaf691842ea6ee1f1ccfbf1c083513aa9b751020323f2c9a948ebec2ddf5be8bfb32f255b09742ff09a85dfbf06f4f037839d538509ba5afbff1fd9d1a790647654ead35cf42dc67a9d98341ae0bb0e5a172fb7726288e0b29dda25b7b42b6aef0077a5d2053000f7ea2228b454ad500422e9545166234a1495e5f8cb3094e68f965263bd74aa48b9224924db1bbacbd912ab87faa360cc2ca86ec72f286d0a8b05bcda8f217b11e6bc758e8dc43f567b8fccad7a1668e24706910e4d7b5dc85ebac32065c891f531051576470ef619ab306530424d3456273999499ddf6740c4e45bfbc907853daf601d62", + "243d79f3ee641ece2d20bfd730c602af4d18be786e6e603f01fca85475feaea32e9b8470aa1d8f12f5fcef4ef462b412498dd825c52b3497dfbf4d226eb3665267ddb70fb9567827ed6bab4f8c7d6546e7d4cbbe79a6ddff4c773c32934493318cc0be8417bb2a3b348edbd71bc8e311c8fae13daa3ab8b8b4e0d039ac36e8d003552a14396971e0abb54142fd9345dc5fde3e89ee0dfad39e314150c9d95f6c04b54b88751ad427e30d27f89816bdcc2b42e662cf8742945e9833f3cca09549f010bf43f5ea53362ea84574c50185575da283845f52f872d5ee0686f50998e625541f446a851ce256685cafb7374b3d01d20ad49b890414cc12481b5c4cd93b", + "4dbd878e0d8e8d1c6e8f60d478bc38da3e8ea9b4bcaa4cfbc30e567eada66fa7ede2f9e5b689088e60dfc4edb09ccb028314d7ea04d2c272cd6f16ccbdb5a2df9bc3f48ac1b1ca64159399ff2dc9d14f194da75bde3778c4c8b777840cc9aab3ded0ee3517b5d5de56f444bf3b5524beed4c07d68e2feacacdd4a9a13f94eb380b672a68f566f4b2d0060270c53d118df313a52b9fa40227cb523e82356a67c773ac1a526770c706a1834d03d33aab71d2fbde7903cde88b04fdd0bb9214aac0faf3ea7055a01ddb936040807e12a6ff1802f6fdab869bd0e490b4e9a25a82739658cb5065dd4f9092c8d0101be1d99fbd7a0920093603f7894820be05831de4", + "8b275b60908ef5d2bb63af6606dc32031856fe6ef764d9583d077bc5dfde26faa83bd16ac01f6ffbe2adf736499184d34e4a93a5d0285cb6a5ea27fffba130294cefb502e995a7396eb3ec022df9255ce37c9e2bcfdb7051d4e80178c9e520fa45b55fb0a01f5cf61921c51418debaafbdd97577c6438b9c37ed7e0433bd4405406f55b92e5662e66a89c393b529b3ff309ebb13b6351192857578bc5cfa229e69a8211c69f0c86e7dcd907a6375a325976dcd8442b9e894ca074c5f682395032dc7bda8ab3a0bac4eb4157cdba6bf2d5f42bc3a01488f1d78cb1e02a2a67f62f00be76ed8f173c3609760c9a3484c129624dd4df2afbf0269f14e073ba1bc4d", + "c05b7807205a7e9d5b2ad3a8a14e20a020a5f33618018def6a09608ed98d470583a0f56bf9d57f82b341c2a7c0a7f0bf5376cd551cac64e38564dfd245fcb9016e47a1c787d17d20e213ea8a7574744db580ae6badef08869a182dbdb32a2c660a1aa1eb800fd2604c8b5da389222b9af92808ddc91a1e56707fc5341f0295502f707254f9a5ff3c1fef479e9099672c88c2e600b1bb26fa78ce746ed888305e0a2767463f46835df0f63978ebf3f4ecf60f422d87a48a40e8c4f1e1bf7e1a5300906037cb2b99e41f7fd4e1fad91fbc331a4be59400c6f2f5082860d57ad32137b562c535bd97d0f524269a803683fb8e0706843954d4b2c37222310bdf375a", + "8b2679f3a22fbf3c88495ba45dd4b7a40119598b5e6be81ddc8543ca716912efeff5e25a7299c7838f3e31cafa19f5b69ad9d3b1ec4a51f254d3809904565bb8b3f3cc0509941aacd736493a3a4272e934c03d5599683fc16152a10872e0937ba5a7bcc70428e93857244958a6bd0a5e556d963038219c6e9626f98c6c23460ce9bc26a13da8bcaf82d345e04bee602852d57e257976a9cfbb5c957982cd3ffc2270fa190219a5501695c074bcae0e60d89b52993f3cfd1a548543479be614f6097f668171bb7a9a95ae0ad880bf0ae4347aae14688d650d1b0fa494a2942fd377d05755d68bcd36467878e2a54497aa4ab97facac0314628b8dc2c5142d62e7", + "6375a832082a033702e44cd6f73fc8fef5199e38c14cbd481d1141045cbbfa638c833b3aef6c5745052b77d84b0aa382f88dfa810f4f5c10aef08daaea292421bc6277715c921066b554c23f04d728d5efd790c0eb3fc612cbc6b3d3eb1f518d9f1efd64c4757570faa4df55f7da9d50aec85cd8d5e1538bbc507b8eca0b33dc872592b8e6394f49b4cbc9ec428408d0faeef660bd06eed914d6755e2fae08657a4f2ad68a63dc9b3bdc28e1b34b43482c90abda1b71b1027796a8babd579f1387d2b66105fa2388e627932fe306cd923ae7bf909c2969632ba49695c5cb27c8096e4c4a6834463179001159cd2b11d62357c63d2ff79889c94389f162b1b68b", + "3b5027f6445cdc19d35e12c4a7956d2e989571a32e5ac3955e11e1b5be60756cf0111cc7e8e5b6594f3e1cdd38735b25b2c6bacf4ca7e697211219efcbe9415b4ddb09c8b7e92ddee51ddc642b9d970629afddd373032d36c93edf8320645feb581e911115cfcabf748af417ef221dcb34550992ed039bef158aa08d24927d875fcdc4cd469f3ba25b10a9c961a754ee7f4862cef7829cdc4ea7cfb2d53eabd1dde5e5ee81590f8f05ab266c14df6e370ecb4669aea8216e2554e0aa6def54689fe52463bd09018145d71151d47008daa218327365eb4fe00bc94bf394d7f50e3d3589d5e5b7ff387330661a34c02a1b89c451c9db809a7a060a04cc7ecd278d", + "c27ab5b138aeabd9f17da364074638ed8642f5fe79c699b3accc6161f42ea63a10d7789cbfc911bc48835d43300674e99037f52b44b5bc8bfb4e948b031cc1b07a6c8926fdb8079c371383fbaf87886a2d08f7a8a723335f671e60226908817959bc362ec4a3155ba90b61ac952e3e0c0d0da6b55af284776f3f7e8b4f5ef45c633fb1919d088e13ca48e9ea126eeb2148fb5b9f27f3e2053ec6cd8e432b761a81624d039008bf7fbbba0594439882d11ceb4bd2a696a9c2cea852df9dfc5b21460a6cc900ce2b3b8d2e763fee5c41b42a5491dd479b75724d0a6f687d4d632ae0fbca313b57de741982a8d814992625086169a4c3669c5c76cb39f779c693f5", + "77cc4a704a52fc20863f06b84b69dba1c54e45b5fdf2b9bae81bb9044039eada8e0525b5ce448d74a37dbae430d1892b68249b848fef8c393d38b1e9b9e6445c5c35705ef4be48493576da042cfb9ab8ee6c20cf5faba102d134a6160b885c3e6049b68027a03e0c1013f608e2c4abffd294372ac7a6b9048df25d2ec9ac4d92e9ff9a18e3a97d9c38226c257a5dfb95dbda12978ae52f833a362d1ceafb0b553a031e9fd0c9cd8c41bce3eb84f125652bcdef88a3a8f284a5cf784a098604d5cbd13907aa6db0eb5ee6fdcd61a210531d55d6eaae07f5fe70ddaefda3df26c900eb778b455869ca008ccc89a56d59244ead89ef9b2a3b560caff67a2fd85847", + "34c4089a391848d81c0fecfc757f088f3e2841b3ef293cd52ae1c6f09920e33854bcff6bc0fa61a87f47ce0bf82efbfe5bfcf9848d60ea4cefe87ab5651b8860a10b361c173d1d790921722a29fbacfc1bdd5dbf4d82acface29d368ccaa83594bd25a77d35649a367884da9ccc1ed0f39fc6a0ab0731b1c011eece4d28f55f5b98fed551330b98b90737f11511d54d847fbf755402acb074334fe6c7efb2d417c2131d86d55f3f503b7839fca253d35ba8962848d25846603e0d0dee744d9175cfe62f812794dd19a9c1a0e20d2e0c4c663cb39ea6e33c1692143a690536669efe10e3d87942ba17f0cd5350d5b2737e61c5129d13b24f3c713b4018e1dc655", + "15ba72a5ffa66d21a2e1a114d33c760f6edaaa593aa189a508442bf553cab0ae60d7fc2b2a05302c5e2c7fdfd987cc13f7ab129e70e996c02f4f894d38d2c6d84b01181e533d3887acd337a10fe83ac4867fdbee95ef1c5b3e8bd3e7b86ba31b7a9ff53cffb237d7a03e4f17c21d81fe7d7360083615b86321272852749e946cae150a8a134652fd1be98493776617d2820e02ded6fa20a6535f10bee7c51e36e72821c8367a9f1ee6cef03663620cf9d3662cb741966eaebf395ad07617bf098d7116e36439fb6e41aac17b85885a5d0d21298cf0574ccd4b278143a4fad8c5f8a2d998d1e2791351c33cb90b86c8010036eaef7ee18b58a7af7a3b5796034", + "1eb81e0ce2ac395448ca28a6da23dea0ab2e1cc63fc8c1f8c556e11d8cb8d38125607e6b38dcdb77e4d9396bd9ae1c281744eacbc4ed5801f65f4d88d5820514422439b08ffdfca9f792bb5ccd8b8792b3f23349335d2eaad6f3e5a3f433454b0f82f39683a69ac676902dfa8474b82e614b5ccba3261acf3b02e2ff1d6652f32895ad0c9af29c39ae0c6501aa761885063fec81e566f6978f106eb2649523e40e3e4d11015b927da17b037c8f8be80a6bd10163a29dc4f110d0b22ac4f43107b10b5cee8ffba710f28dd5c1a21c9884c7c56c9f353fe2264ba8065fcb0591a2f63df893526048b5ab384b69ec221b6919d26fabf0675d06d7430531979d325e", + "63d387e3568b6703a67ccc15cf9187b51618341e7123c33814465d8c9ac96f2df14fc53ffa165b1c152de82a95d4e8560123c627c44177c1aed2bd20f9082c466337b8e38ab1aa8966a599b7dd86e4e1592dc3b4a6fd65d442ddf4bc4c7f9202e243b9e5ed5bf5b21c2264340106b0b21e108c12bbb0073dd4f5ed8e0f559c07b6b2bbfdd61e5e5a61e23a52837d20dd1927acf3299b0262ca0f3a0178b5a05345d9bf36eeae5f07286f767a319b991133a7b8f3845ca556f4219c4261cfba11c06a65e170227b494409b7ca73903affe56114d9ce0e48f0a19c32f76a4dc7f73073a06485ebc979cad0ceb22be79c5d84a2bb8cc32ad88372b3342d27c513c7", + "290e51343ebad190e01e052f27ac0ab84651bc85fa6875040d64eef0d54805f81bfce734639c387cca71b8de63c6cf82b143a03f6d1b312f45987d310324a05c1b2bbc1d261a2e5f779af1fe003493a4653ae9783fa5eaca5f48103e68c059cb3774e0ec62bda7220b7cead33c3848cd7cd52afcf55ff759124d77e42dcabc682e02cf28cf57cf2d75efca49030cf915b3a660550994067b4b9eb5ac447d98a0c282dd82da4a9ecb3ed261c61cd13b4c8ee8ccf47d1d4b8bb9c4153db95e7cd93527ad750fb4fc97614335e7ac59b1636c5acacd44efc91a6d3b9754b6fc29f9199723bedfde3f64264a99c72e797151efc0b1f4372a024e3c5889753678474f", + "d5c84c26b6c105a548c16e58ad779a7edc8ab40c50072029b93ecc40e0872f14b6c966b964f424fa69c60fa06266d9a2dc52bc73517dc19ac96b9ccee76423192637e8a0c69b25c93558a1dd724484673eb579276cf10a4f6c59be7ec54fe18d03b7bbe6c2281ef9bda1fdaf409f336080b92258f82d6748d9ec4847eb5bc2cfd5e4e0ad5933e32dce2620d5414f2d718c3e3830c7432cafe82d815c69137eaef5ed8bc88bbb867d41a9776e8387fdbea6b21fd34fda92db037ae6284f3d5141b7098cf0e930c8e26609b65659e28fff9e0e0e79b3909b0409936be1195e205a3a7cdedad1d708df61026fd086fb635a1b67592943639e4f55ee448000c65462", + "b69e37027ab0f49e5b2143b503585b26384ac702ca3abb18dd003cbde7d8cefa7a9374b4679e2cb91098e09544bae3a1594f720269bb59f1e906370274397e4db8ddc79cd7fdd4afc00f2e9406da036e49a2a9ab40e8144774ecbd4e73877d8fc224da3ab9351d54ea22e5c5c8ddc7672559540daaf0629805f586f93c07e3352e6f2ee7b9bee86438d6d35a842188a4ed41d6b775126761427dee757c39d61bf105244775b2e6cbba51b6037306e422cd00b6698a9cb124e87f45035f1f39870ee98cec027d18f91837a80ef738f953441add73f336461d74fe1b27cd7f27567399f41fbeffffcf1b2d6cf4f96bf315dcf5221b6768f475d0d1d9fb41ea0295", + "860f40b88b556fd4a230b4dbcb6e1a82c7d28561a153af8ca49d28e01c7c7ea3faa27b75767aa7fbb69275514e71462d84f606e001352b4fbc20d47ad134cbacda93af0f5faeb362643e8707799b0c82e356f168eb89a5900af2c58e32504f254ac3345bd0b5e08a31df525b873247b096b8b0b51da7d818f6489f6ac9227d6f800ef181ac89ee9214eb7719a51bb60edf4cc2651d05e9fb832b518d502e5bc9e49796a9d192f2ebc5427a0285d9ccb6498cec4279c5afab218ce507ee30c64c5930aef449a03d56a04bb341f1ed306584de90b81b29b2681b8ea4af384596ec97515b8e2edeea6a1dc417ca7faa0bbc2b5ae053a2ea42c7d8e57959f6ab300c", + "2742da4850bc59fd7de219540f93f4036af5bd6bfbceaaf6bad1083a07893390ead4048e6a6a6b1cebb2719ac809a6723680c7fd0fdca2b33065c95c1796a22ce264a34a17ab9638b0d3263e87c8fa690c1ad2e20688c0f654d6aeea578ca0d5ddb0e62873d6926d2fe784bfcd752dc393c6af2614162cbb7cbee7ac8c68c765c7bdadab4cc3777c263dde66aa3230921f99c96b73ac7d82e273a207f629eeb5ea701bd30fb8bf5479eee1c04dcf636faae0be427ff15612d08388ac1f275257cd9dd9dd1f8927a5861d2de9ed2231cc1cd524c1ff9a42c51e801342516e0e8b682ff71b2b9c83cdade74299a587c6620981bedfd0c04cd3fa600e24cabf39bc", + "8698bcae249a0cab2775d4fb2d22f290a51405b599f6197d5bb4512d11902daf7ba95a801f403f7b55218b36a547812b175b96cc7011c2c83af832abed33ef266c6c511d64d991760c80c3e1d357797f05add8724c494fc47764c43ee8f191df64393271a1dfa34842bc789a5f830b2a0a3e09e0b2a8aca241be8abd74f33b01f6f6db8a09be2c9ae1456e8db1eeee2925d9bb673639080436ff87c18b27a14baaa7798cb169fb968e610b401a29fc13e3e2a8642e8ee566b969a8e06983f1b5002cfdfac455ffea917d7cf38d5ef7e4792f525879947acbdfc886c3aeea80a92e583d4e2650ed2c868eca700914ed629b684abd2865a4adab960bb7fbe70f84", + "67b96731da350435bac5adbd5054269bab49e5c436ba066403d1f7e52767eed3af2b0abd7be337b735b3d8f3ce964bebbf209658b739dfd9b5551c4448459aed31363f18ab4ae5b94c4b14252338e9bf308503066ce3c7fdf3fcd81dc9e46018cf5221a60068256beba85a0f38af1d236fa665920b1cdfddb4d04ea402b4457c2472e13fc10bd01ce40e9763e2c57f7c63c295ab92f1b34b48ef1869aab7eb43e4054bb32ad346a8fb6ec45aaa78899eee93e8d93432fdbabbf8a17258d48857c768c6910c84f457e332cfa49a7c20c64d99355076ed610d179194d6b6691d72b1cef61e8934c1a69b55d7fa07c1dc1e5427c904f7ea8878e07cd47f5dea7e79", + "79223f7d3c9f4f3933b1cbd3506a9dad2eb092dea80ad32a43fe982aa6a8fde73a9000d867f700b2de7c59d43ab221fd864ea709dd8a0092a2b3009ab533914fcb2885eb9f6ed591ed197868d2e32c9d2cfa19e76733b704291273348b790e9297dc9dabee785fde55d9d9adb171d97b173fcdf22afcbb021c2f821072271ad3eb1483e38ce54062f06715d9595b01618b2b97a5ad6e50138a516cdd615ddb720c6a47505c6e8cbc3caca6182127e77b0627c4a1ce68a4a427b555625c5eeae5bae8aa892b0977e335e72fbff525b48538ba9052c3817cf633d6b2b495844d5906877a02c2ab1161b8e20e646f23bcbdc1b3576ccf384d9194f55141452fb00f", + "8df46648fd80adaa66537c42135098a217f8e2ebcba5c57ae1509ceecc761b452f65a2890866e18ca330e53aedbe20a5dd18acafeb7044cf8dcaaa62de31929ae879087068c608202b5ba0289e0a8f4e28eabfa4471cbe61e0982d5709ad71e40b4558ed4260ec5df590728c26d9aa6d7d8467070cd710113ba7936c47ea7e23f4e76dc043934f98b35778260870ccea43eef395aa15c200572c0180200398127b76fb6587ac450547ad86d84c8be09e5424d4f31b2d08888ecfc78c4a1618ae9af56e1ffcf8cc25b301d54040273f902a3f8a3ee66c64d894c7e8687c225a56babcfe41c09cfb1a75d3beb273833d421a283b9e1243fc2366a55f070fec1d63", + "a69d10c7797c1558e59dd50bb0f5fd37e458b19e32d7c3297c80a0e54f6435929629e08a0c2e580a0897fadff382f5fea2bd923f7202058f43011f14e6f0b971cecac65308e30c07c6024b7f60e58add69f2f42c7a0fff47ffc1fbea71467bc7b3d70c9e24acdff451f69de27e59e7342731a26595d75a37c4a15a03efbff15821d640e33f0d7ff867ad7dd505c9f3dcc7d53d98f4f2546d615f325d7b481742de258ef9419a4ebe58cfecb3b55d062058d7ec5e0a362535af74873d270422b844cc3ceb94103ed0d0ffb054e569c485632931c8f459296748973fa9eb5cbe27f21e4604f73c2aeef9c22140af4507afbe1ef51c8c9cc1ac0f3f54c7fd69030a", + "6226072c27111f4c523db1a2578b2d67c92cd26e7369b80752582a577d3e9eda9f98fe687b41e4ec9807c02406bdd9a7b936d95d6899794b65182a2f4690ed01bf04d4107e94551e1458221e8639bcf266685b30920dafaba84acf579f45fc6476cabbd7bfabe6b4df5cb96f9f369882f79016d84ac681f4d0ca292da650dc8932f2f4357c83321831e41bcacb5a33a471c01b4804fa914ca4582219d844690dbf3fe0978c257d78c3f9fcab218b2b560f24fefa313c7bc875fd3c9db8c5f60559970db31f23aa3ad1bc40a6c99b64b07719206b45aaf79957d11b90c3dacfe71a2e08fb1c09cace3b2204f627a722368b65fa61fda363f2e231e6990348da42", + "3b2e0b4477d53139f88f0e225a9372c8704db222cb8ccfb176cf776cde9f2e3f8d3646fd008fea007b42016fe1386a8321b7a9a96d5b6d24760f679376c70d9728c047192a64e94046bb8a17d9db38666eb3ab7f892c585cecc5d859be35cd0408a76bf6142f488792342aa947f06e9a6ec53939e0b6139040c07a8967945098e92cca1e76bd58095155e520d68187580b3f5a9db564e54cdda45b90d18a8afb9d0488c79d77b0103e7cd03f24e7d69c4c4c1bc91fce955dd9dc31a866fb6d9d77cd17dbd86fca8f35ee9b96438127479119da321f90a5ff483b061ec127aed91389bd44484ff836c413bf4262ca4f5819ee4c62d0072023d506b8f4b5a6867a", + "825d6abd0709f4e0281ac827ffbc01210a00b0ff556a0862fcc573c63bd9b25d5fadbf26f8da815cbebc4a26135d9d8c00e50f0c038c643fcdfbf921ba0ae7eff7332878ee3ed216a4b24324c0e1270d6d76d6fa7345c11d7fb3ceed0f4f33dcf388382f15079a02fff96d448e064f77d7f62662f46d61cd4ffa6ca753643a64d731bc429d5c03f041b3b0eddc8079c6e2373dd63f1d3836ea43bd632e834460c3e301486fe211fb0d78714dbf37d7b387737b8b248f2f38c86c71764482b042e428b0035a5a1c4a2ca1508479818f44fbcd0cc46835dbb675e7c6a2765e05b2e3742e4946053a855165ad4c4cbe4c94d16b217b37c81f4cf6287667abf4e477", + "41698ad13eddb22248ea847cd0d050edcf444336f0dd10798a12fea23233828d388642b9c005cfe373817c675fe2afe794707757cd33a5a26393032c2db568204a18d647c07a37444975c5e334bb07e5d098d0d278db275b979b871c4c5e322bb5234cec7ff2d8722106afec94ca6e2005390c283a01c572688698b14a04b1e993387b34ff03891b1211c65fcbf16e2afb57aeadf05cfdf51ef40d0a1ed5dcdc2a3702e7fa0e6afd2dc8d97d6c5c5e318ecee546a64690307e064a278c3ea2a506adb412c5ba1295f8238f92c9c6f3a4a7c30cb95f04a1706e57d40eae2da2181d605a13993a3a17c87b10652fd7023bcb4afc7a34de179e7e54755cc449dcd1", + "88f73842c116d787a25051f0bb2493de1ca0078d84a86f46e7cb9424b48d96029e2b650665ad0701893aef93de0a66959bfdd718b810374c785b0b8a0185833f6857290a27b6cd2997cf2582e8f0c9ae8038f6ad5d54077615be68b4df10f00e2ae99c6c5e506ab869c97fa7d74a62f00ffae3d5745784c5cfd20a3865f81d603a6e8880f939acc4e8b38ac39257911d4aff8ae77f544539ab2d8ba80b01d6cf8a14e0bb8368bcdd782b599a941183e9aec1fe80be75d4f7027a266c9edec9906a8d998f23d0100fcd3a0e288ca1c76da97670d1e597b16e7ae86cd663bde05faaf5ba8887def36c6aaf27411a35d2984e0beb8f968b09c97efb8110ce2c4b71", + "c6851caafeeb50d5d8f5c5ba6e1b3997ce191585c08cb0a0de581728cbfe0a46345886b716b978c2c533869b667605b967236bda055ddf9398088ed744e8afa4cbc1da3b48f4166b4dabc535a68f8761955dddf6e9ef1044d414bdf8d085bb918e800056c3f9040ceb0d15d7a4eb7209139bd6911256a221318cf6464da81a21b4a16d2adf84c732a4c8fbc27dc0a0c6130e7054367a0a40af8c98579e0621dc8bd2cb5f34d7292005ef804efd80995452520ee09a76cff3a9c4fcad9c451ae49606c429fbbf25604e9f71c7d6a9f02661311d6bf8c5cd6120144b16f128bb54299783c7b7345ba1f4e0d5e40f73fe3bc28b791e95965994c518f0bf65bd5abf", + "3551629b0324c7e6fc7c8fbea21a4aa86dab67cbbd35f2d9f7fd59d0906cce23c5176dbecf64d56cbadd61c17e232ca59d876f160db98a472e64fa093e57abde6aa55e6c8119031874e899c50edd350bf41be48e258825055869d52c3ed07bd0551afe7141442e7f60d802abe5f56747cf2dfc584af86bed9a7e38699521ce1b38f5984d7d16d1122228d6b67e493c452448c8bb72124e6c0aa977222242946c9f987e765347a8fbb325f88c7a8de5fa7d654420b29dde218a3da98a5396c62207d0c4d7657e0e3448aeb0c311129ee4b6158b670df2ba81466187bc764eab460091bbc9a099ffd7cf21c86e3826b8f0b000d8f303c6dad58ebac47c2c3521e1", + "1833e5254faca2fba6a8773a850575980ec4da250f5925faaf457b2b61652e94cee7b7faf022c73b2e699d9bbe69d2a65d7ac15b096f8c8285fce8d4247f363530524a947dccd7c84d0211c95dd69b9ab990e85b54dbb97478dba153a6a85d38b7c54035c9a38f529bab2b90dc01b83a39616d61998147902b989f97254453c88cb34c5d72f8d5df5907735af9e1ecf3fec631fd6347d82361e25c6c224b652d7270997ba3da50bfb512b9440cc81199a1af18b040ddd8e35399afe4ddbf100c758dafe6c8044c74bc34cc96d32bccb97d27dc0df66d0386b4a8be3d952d3d2abcac380913b716bf571e1c99d548965392ce4311ee8340ecb950a5e826133d91", + "24d00921f4bb0a684cd20a7d840639092a4f55867d407a87a901963b07f30d2404506ec14176cacb561b671e4cd6708c176cbf2968048c9bea9d0482fa937ca8bc019e461bd0d2d629d845ab14094fcdac2d7dcf9ace7bced4d4ab8f70edcf409ca103f5299cdf5e3cca91c639235f704a551a3f96b725938d1324ee15c1f263a66d47808049dd10c57dccd49e8061003561af34b4b854307d92adba038445b38c8cfbfe1a0b55e7eb6d4d1629f90c03062f13d272683d7208e08264c8bc7949ae46b407c57c4dff9153ccf14ec387b10211ff9fa7b94fc8b656c8c0d4a0b22fba410e67c433c9674433bbbdcf3872f7c16404f0c14f16bce6300d7044ad4883", + "c877c685add340b623f85a59daf248aef18294c60822f60eb6f20411ffad147fe7af3b1a1f00f9d72398dd9630dd7ca268f08bff00b409d7607eb3c49842fb68d8f8aa51fb9e8bed59eb9af5e54bdc5301375a70ceacca5e1ef1fb7f4f59151a42b5ed04ce6ec99446861530902db29c60ddc40d79fe02864e3b48df103825af15bc66cc9d48f5089fa3957450891ad0fc237bc9abca75f5f1a5f3a438c00d67af61253266a0cf754518e326144dade1d919b53294362cb1629c628f4645dd5bb3a0610fcaf596deec923675522d4df1ac27859b49f7d746bcf50b5631614b641561a9a77d9cb0a9766d269e114adeff709913f13eafbe3e1f7fd5652416c4cf", + "6fb8fa913024c776e0e4faf6fc81648ac3da534003f0eec0c5e83322657e240c082b2eae8b79c0d559d0cb1ca561bcb14d4e269a5c21d426a24e5902ab1551c2cd78c7ae58f91b1eadbef4a3438e4209476ab333c58b35487c032c66a7fc92a98a41b887d42b66e0a85c14512115491a40defb833c1d7203e92c7639ee0426cfd17f83ce423bd76e940df7dfb959ad61fea0bacd057ba0ff0a1f083bd7478ee5855edc2d3c730cefdca8a08a4ea171f0b5cca5e1a99f11cc351d19a5a22afd3a0aecc91ce5bae587a277031d3203f7490841fe59f74c0d84adc7b1620cd3f533620c094ec82e8350ba8cf246550f5c92de4df2e2babc9e3a815cc6db15e0c0cc", + "ce22a5611841e9f8be2dbbfdb8acb6e05de5a23993e36289801a3d147d4f067e123dc2fb7e4c06b90986f213b281fbc8369fa2ab458bb79bb35550d920573549986eb87424a168ff5617da8712751b18503334fe132d79c4c846019844d0108ed68feca079b5ecbc12813fc76d5323c531e9032b3a858ce0724295d3cc951d81539376c8e820118e510cd4477e98c88ff0732b20f7964bce0cd4e2e4a31a134c58b8044e4c8cf38cb1d72e311dad11100eeb5a0d779877700ddf9555a5ad78a992cd76682de88c8f561b0626b3b75aa0d9e14f356a3138a72ce57a5b4a26378008327a950262bc9741281f37bb7bc67cd3e0f0f62d1c8558ea1d8eedca0c1b1f", + "6791b2b2ace7ff7f37800f835f9428c6c61911b356b12b95171e81ecb22dd0b37c3e2df1f76c67bf79329a3b41153268fb22a8dcf3bea2ce5bc1d100a99314bf37f4dd82b9c24af9cbc93b7439f0b5796d7e79be610cb5e52b657c072c11cf5fedf176a3749552584cc6ea314919c384f9ac29807d52db1a1a443c5b881de2d531e1a6e7e941023d0a87ec776974f1b39e24bc3a1cac3910f1df1202ee96c6c3b9a092a186646196c96754e426f18bc8b23626f342fbc20c139b2bd8341796032a6f388a155e1452c9fa48b873f995c56cee80293fe5aca546a7ff35e9a0b31207915cfdb2f40752a8e225880bc39084a0828917302f1f507bcd31b2d7bc3868", + "cc2f7edfcb00487251a1796608bf984d9b3f18ff1b666636eca9a1f9f772e50236c6c36941aacd9449a984537572c01c54ba0e694140390c55c762fb7364b0ed5651232a0c6619e360a95503e48c340d4bee740c070c482ed34ec871229ef35cd410376e7a21ec660722c67fd526cb7f9c16038f66258f0936bcb27409895dcc9a8b8f6450bf230d40a722921263a26fb1187c56355b4cda2ad759ef0a1fd653a8d9180ac5d3ff7c384f5668093dc3213ae7a95b29fb6a3b5e7cf7085f839129c4bd12a27eaa734de4e4637c96fc74ca21d6138e2cf82f57f2b990bcebcf9a8381f04b17c3d53d72d9a9c9994975822f4a2290e408c0b7d7e4c4fb80e63e1015", + "912ed6a560c1b7cf6d986fa211d3444d9bfb1721887a2c817b9ea6eb3706bc7ae6563dfdbe7ac4c37fe8ad7aae48a5fc478c8f44d9a19962357144179c48249de8d3b136850663083678a280f3bca89855a3e15c99f615e9d1ef38bb16b7af2d6eb45590fe8fdd7a077a2295bec66d25a9a791f9af4eea851425b4da91c20a8f27bc60005a406a505e0bde36b1518491533b9b7322ba39ca34b2c7395630afbc78f8b5b4f0a9fd123983cc615f06385a36e6c3726a4c944370c33ce4d93aa3e6f6a5b0e238a6df2ad1f4470040dfb2c4eaa8db5ec12e8cafcadab79f092eb3aa49d511809ecd977a823a591f9590753c89851e0777d7f1885d43be481f231a84", + "4c2d9419a3ceb8602c38845b21501e0094148a9a13bfa6506fda486028fd255d0318d4fd72d5342324150c0c14c6df8593e022648e21db9797c9e1046d028b1bc09c65f2eeec5aa40c02b2473c78a644869ae781837ffef1a82e36c9fe824388c064137f52f1505af13a3ed2a3dad689f12949cf82ae115a7988035edf2599ab01f1449a453bf119404979965fda42457db8e055d18ae9e2541edf140e3023052fba88cae9365bee9760acdff87aba4a0b17864a21fc583553892b7e722a14844b2d264b430d5005380fcd00d21104e8b48d8872ce126c5de90ed1aa9d7ca67e6baef7b9d55b3c6cdc6ea0a08f89f4cd4de1cd5eaecff85f21854efc234b6e2e", + "2d0e1a5a943523287c5eb4f7476bcc2191fc648e4d08e67bbe6e7d93555c30a04abb8afac03042b230cd3eb529771bb170aac4975348da87c14612c2c120f721ba30405d81a5f06c40bc02d2b2de3f005ee2f609bdbe1dd55b6beb63eaade772848c1916dd29d7cce71b2653d7c4507d50b77aa748cd83295137873bbd739f8c099dca50aa65cd14e1bdf303302e4c5614ce07cf81d52c3113f866ef625e5753321f561196a8183cf7c0596e93fd75afec9480db0d18816ed8ac045fec49476fb699b97bc105291508012861f140b27e076893663477147632e177f5122cb6ab9d0019c20193e963cfcb37931f9f4f378dea06b543fc75c771c4dfcdae21ab18", + "2c070c898da6e05f4f9d4830ee6bed1ab153d0d17e69e4bb90c8f6b3b6706b1a471ac43d8961d93805d2f4d0356af554dd54cadf4920220b004da54ac5653300bb21d9ca24473acb022542a7d7746c6c4cf89df3e9caaa2da916be3a6b53d10198206477ecaef44c09eb9e85ee1e1b8dac46538039bd926c54a777bd5a77facfe7f2ca51d28357b4d9b5b347d3899215b5633795262ddee395fe9d838c92c73278de528bf2d3413d536bf3e4d23adcda3559c0fc89dafc2e443a2c6baf7e9d46e1d742f4a04e3415f170e7ae0107f7a455419d9a68df9e39ce8ea54888f975c848ef544abf98d4f368cd5273d6424985703225b70d018a060f3fc94b00247190", + "319ac4816abee8d0db7a06c74fcfaea3e4dc25f771eee40476d05460c951e4a702a86661d9bc9d633c1e0786bc69de173fb079c94059bc58ffc470e0b55a73a0435b8326a3f8de21c117e12d316169ce4249cf559a07e917c8b8cd636242119f09df6eeee8a2fdb0a8210a6767e6243a9a670337d0301d3b96a1fd82ac71cc304bf3ef79b34e54c0139dff0a246285999a1a529ac404694338c3cfe54cd26d2c9c6e2bb9d7025b887d2997aef99ccbf5d55cfe5e6b80fd24382c8aebfcf178b746501e6ec58eeda2e89c6d4211922daa4d62dc860d22e3d213fe1b5a745d1fb4e28fa34e21d7df492bfed5281403db7f9a1e5c161d60fd79cd71a703119d0393", + "5f83538f1a5f436357d98cad749cf0288c63fc6e280183a6e7484f1bc74720e68bcc298ca8fadc3d28540f867140549563e9989f27fb9087003ba238b842245c58a9dd18f5b61189837b43567415b86798709a1580952202a3b33c8d9314cd554bf5f30ff62d1a4efda2406f66445de846d4a6d2cbd43ee60f0b6d13dadea70827853fce770defd12246b43626802fc1f142dd2fc8fe97727594fe06aae090e27ddd044f707ba2e66eb7119e3a8f6f4cb4f6f9060b3293dcedb500813989f361d5f6af9cf9fc7e70e202ae9bac5f199428f1d11c71244e621556f1c74a92032226497bcebb503f28a81d1adc1cdfde00bc0c70be1f342c01c5e2e73f59c17fc5", + "c3ab79c3ca703155b13b5e5ecdf61763af58f21e14064f937d1c6d7b02c3786ba7a3e0f1cf5b06d2982885af03da90a2ff979e59d736949b4f51881e830034d7978fd0873711b90e1ccdf15b457e5a1d2d5ee335aa21755e5787d5e02626fcf99425c65ab69720f40d4308ec4a5171cadc9c5a61fcbdde1af1a88553f726a55d5969fa13a8f01230159c6869830a8174fee77a8c28e4d420190c6e64af7b0894ec5999149b9fb6af8b55536cf20e29310847796e125ae4b575f2a07416603b95cc86d603699b65123aa2ff75d2298776bd0f2b24ab37e6248db75a363d17d870b6114b0f955afcebe4d626e4d63f74426b266e37491d566e83075f3255669842", + "5bf82ba63bfc8d2fe2442b093ebadd822918f4a5b0af53a47b919b0834b7dd5b05d673b09bda165cff853d596aba7839503142b0afaad12d625334a20618837a54cbd8fdc7525948fbd34f8a3025de3a65b442c7f3dcfc074f103a71934c2a4169763225f3a99e79e0f1f3514a2a52cbb35166e8f8d4c42a0271ccc916bd2f65b7dcd7ae576bb41c2ee18d9da51cce397eb864e4f587b66ea2d265a14dd9e16ae0c092c194663ec58d14f254d660519bacf21f2a1a4844e53611d770261cf4e8fe7073419e762cd1ee701b2450485623a6c1b96606e011be73bcb54b293a5f700a19c218999a56bf9550b430d1ce211cc5c4768f1bc90802f8c95fc694b94af4", + "2e50044987c77e46fdd9a107182b0f09fdf44ec943fc15dc03fd981f306bdacaaab2c5f2f42e4b67863eb43fa6fa8ce2129d8ce4158885f34ee5564c7816ddfa109d375148f0043581793098d219950108d1b1756f30cd4d9c95d828e3992eab432e9303cd00c4512cb57a4224de8358e2ad1fc8a3631100df89fb87ea41f4fe9316bd63e601c3c16cf235fae286a9dc56ae2c437014ada0aaa2617b8aacdb79d058d532d99ad45c48d302d1a825dc45327fc0e6872fa0b77b804e3b110596fbbb9b3194cd8040bb88df42e03f0ab107370b53203de52097da162d56bad69900a784d37fad1d7431fb2f0f433854c833f1d6e61932d5c3a677611e6421427f17", + "c14381893b523b30949dd8e5d907c69003204b015673a49571efe1fa3609098ba34b94a2215f4719a4ea5d70ed581e4af26576b8db74ff9d0c9cb33c68d52541d71116c652a2826ae81a90868e96b88c6640b4bebb8251473b9e6fa423d028821ea2a0c573355fb7f5b4508b707bc22e412845811dd990bf98ff6ef2040873fd3c4272e5030620ce2c2312f9ee4bb5c0f81c6d15edd4d1e2ae5ae6c3d8be55aec04e7bcf0c8eca6a08389a11d93c203f44cfa8aa7da761d4aefa1ec1ebe3aff2725d9e650c03cf91abf7421f048129d0f405c55356e234400a9a10b2f3c994ec66593f7e60e6fcdb99ba6449cf60ffbedeacdff4abf4f9410cf707088d459aea", + "87bcab7f65fe1668f1c13654d6d33bc925c9609dcb508cfa165ce009b00774bafbd161ea880defda0e00c75e2466fcc0c8af5197e7d23ecc4bfa2d1dfe0ff1e81fcdeb7bfd6efbe2246a0d298b51c11b1b38d5fdfbc3a25c0bbcc4a3716a1dc012cbd316204606530d86f11e4b1b05c25e3a951223f1d7ab5c1378ed8c4eeef8f0654f3a87c34562cdcbe9dda5dce4d840752268a3aef429973053923f01639aee4bea5e246423551afc80f877dc5a4b380939e38ff066ee367d68c51ebab6ff90353e276e94e44d85663cb77a99f0644467018826906730e62a28e5246ba26b9d2905f78be9bd23df3d92f3ef56457735613232b6d99df32320d418b387f47d", + "460c3c4a276a0322038e77edf92c26eca574153668242e9ecec974dafd6d2522debda7e37a0dc9c77bbcd4344b13fd31a1b5c1739c5d9d3fbfa13d0a788582c9fd1620c79c77a230f99c77614db471901fe4a332bbb23d7d4cb250198e8f1a1cab8c24825ee8d37e2f54f03647507e3a6c9beab854362a9d155d97e27baa4c41de59949ddb88e9a754f93657dcb2ce8f679048c155633f110af930e85383606b37651a9ef218cfb3e1ae33addda53d074f2fe310a844029ad598d7b0a1b119099172e54ace1e451353826b6797b0ec5bdbb7c4653a2706ecc781dfb62e272d4c8db98afc5e850104c3c07f8f9fd472c756c8c011858ffafa5c204004c5c81e9b", + "d9aa20db877263f475f31ab7737a6218fa189adc722090cf07dde7c36632420e1080e03ee6b24f29b06df2f7dd13be75f8d50e7bc0b78e1be367b916eaa2651d7593bc6c64140b232ab2a413f7e5a4396fd680a125f58192000021f29352270bf608659a94b29d90ff19891d2d0c6c89ab5ac37350c7edf0e1782d8a1c6a2b7031094a9a7b2c1c9ca96d997cbe7d9dd97ff8f00914e7364ea08b6f93fab1576f4faf05218b714afd4b7e0f6c8ef154d73a7f825623f354a8e14292f548162512ffe9d7a56b41b06c56dcff36d4d620e8c3ab10957335a2b15781bf905bcf1faed6d77cf44456a476ab2f80149fb1e662dba904ff4911035f1734eea3b5a88878", + "668c117d43cd14cd904f8cd7d32d78ec0c60789763926efc1444ae2ffa2c982d4279df0fe682e67141da0371f70f12b0db2039ae1d22aefb94268884f244a723506ae5476b7897efabe119324b39d8c3a4ada86d8ab81a2b8bb8dbd43a4f86527a3e6f83f3ef7a0bc819a8620b3ebb869c3449c660c6014820c231a54fba91bc947e905c92b6257df2b943fe05b24a6873e46c19400f5062289ca66d17aadc7c1bd5d6cba9d1cb7d00c470d0b68cd50aab6d1f2cb7ce7806bbe5537c1695856b0d4879803ebeb6308bbc7e8d9e3f6f8a5598f558440381111e5cab2158d0de26113c6384411cb5ebd60e3a5735d21cce6f2c9ced6059c391060fca21b6f1534b", + "87c3faa72d625db1c8e0499c7034e3d93e22b273d8df0cfd56332b809d76a7d072bfeaef04aa8940a84630138a3567fccd1ba27086f96fd00114d6ebb9be519fe4abcd3d8c2238d44bd8d94f07c4ed417364397960f13956eb19d3080399191d4e4fc07a88e084c7ec04eff02b1a3a45327549feb31a059064967572caecbe2b64906bb17ac18cf28b5c31332df7270671f72719513e3be96cdc291d05ccdd5a07cdc0813fe502c45c60f38b8753d397cf64c6d2b29f8eadca7f7c11c119dd35e2d183b2ed741831f37c1b3640cc101eaf8a21b669e4cf577c8090c11eb8e425e4539e115149a6f6e839204943befd713ee768c4c0b3cac64b55658b9fd21ead", + "3f2626650d8a081f0c38309e9d4847294c9a49cd2d426fffd21285f656daace34e681c37a562cde8e54d23c6927e10318bb70fc6472047d1e85adc8d1176ef6cc5da2b8fafb5319da04da35e4b97317fb4b47aa8cf61d516225f9a441ae5a9bbc1ab41d2e1f036a64c8669d15555cab2ffa0a127165d4fe935774d2a4d30f64082740b4dbc160cf51e9e89ff560ec5c160d997b804ff192868446ab334176f705b031aa33cd17d1f7230814ecde8cfaa49a4552181d697d43d8920f2aab4b9e2ace5e3b6f5c02fb84d0cd1d5173845521d15bf9b7cf104f6feca33f011a553ee7443f782c1e6acb0367b89c4f9cb4b871bd28988813f4a7d66337ac0688bf260", + "422ba6990379c92eb09c3784339defffda0330495ad051eceeecd78ae7c4117959da140b4d37cded782861a6a7ee1a9ed90ece7ceba173d5cd40dfdb48853d4e9b20e52bb9464f84c1883a90ac8207f42d5906cb2f76fae48023d9588c9fed8573495a760cffa8d38e7044cdc36d3b703f43698ca11cd733b991dae8381134e031e9765729eb906fa077e4a4311feb93a2b11b83e63e67e6abc0d2b26b3b48d2c9698c60073f6a6d6848c1977cf44cc4efb989b10494ebf9c4c3762bd7e4d2099a8995300ad2eb25f304635b03c35839772403bff9f4b12f332ac1f87971614d41da0e14fb7a5b45847fbe1d35d2e09ddd7335dd50d0dc3adbcffb5b8e5520cb", + "4c0080cd9770b48d41a4f27842d09b64c76d59a872a30cf5ab267dd46caff02fa76e86ee60c8544898b5e88595de18b762b828c82e290b25ea4b33d08439f045949efaef7a02b57915c34c62b1f06f96401d4cb4b47ba03cfe73336dff5be91fd0a9f5a3499523520eec819ae9923b498d2f0eb0084ad43974eac1191468da8714e2625cd7a68220955abf017bd141b1e220d0097ee8a8e253b72e750165b97954b11f30c6d19f85933b8948ca184102711c92bbb48d11152b99278487be37b1d367a49376170c3a28501f0818e844dfee3be2cdc9f323b90e5e9922e9c65f64c34118358a6cc3df2cb445e2b2e01227d265b793ea017bb3188aba5b3fd7b449", + "5caddee890f6875f6eec4a2ffd6c1aa031425d4eeee68b6e23e0f04d3275912957b503a84ee1df49f9f0288325750789eb5c8c58828de844b4a3e7ced951e908dddb74cc737fa8037954aa4a9aba4f6538a535f489043ceff73344b7279b95cbc29ec571e5ef3fbc5e9c61e8b88a9548da5ea36cdc537c694a75a6c62da6ac965cbe4e10b54172c6bd46ca4b7d3d3dae046ded4cfd954f5e580bb07143455d5747d8558bd198552e8a593844a9b95058b90b2d28245485fac8b7886f148f80b75aaa999452b473fc2a360e1d1370ee7bc0cac38bc85db320f098323185a2bde85fc0fd2e50555b6b9988fad409f14f62797ea245b275476ef767a27f7a5a3caf", + "d77c274a57ecacb28fb91a4103f0680f382b3469b20aee09ddfc3c31fe74d3df7d1cc884bb1be8676cf854c0fef880074b3ff8e7bbbd03028d1009b4a5225c5f6663de8ecf06409a2626831cb9aab2a6fb22c605a9824af3c423c1995d5003d65d88f0cc4c8936618827598a726e1aa1ad5902ad9e43161e145dcd2e16bfd58a4562372156a11b5856dd443d888a87a123b81581bfefc3711cc10512d1cb3b523c547b12f333587d8caf59a49d4e30f3847e5b996cfb9fa338b5d640d504951b84ba34619c0117a0eed9992c26bc7a9f2dc680e46c1e97c9246a99b8e08c0111851aca0c0304cecdb447c3bba21a8aa037d7e19a092c120bc35a090a964723a4", + "20ad5c691a6852f98d4d2a8be6fb66673652301f5f9df070d6e1c3d54d0f36c975803ab52fcdf7557c9e405364d2347732bb7cf986710dc55a0a6c473e652add156e3d00fba3da9b62af2dcd4dffceffffb2b7af287d5acd0cee31291f6c8ffe2cf77eea6a3abb99f7f45992232eeb9ad9abb31b2bc1e6b6d7b75dd13934453051f3d7fd709ddffaf6d78c9a7e6166e630641b41225c5825deefeec13fb37a540afaf84454253bd36d287b1f40c6a84c7cecc4d71a0d799d68ee6949fbd04923713707d17ca3b155f687b19954b7624443d4e48f444d2609053acd5fe51ca6d33093b64dca201297e15f703baafb3a39371ef49cb9aa8954c3bd40996790a54", + "48456971f179a3b8914ef1fced8723283c90c21353bd6c642040ace34f32fe3900175cfcd735a15baf4d94b37b3cf978ec64db5801572221b56a2faa399d6a4c1f0d4636eb9e05c086795f8384f2385e1b5adb52dc63729cbc8fe3141cf736e7d974e3bf531d8242aabfc2f0a11b99a51df86962a52430a1a683ec65dd1dc990568da18491cb308006cface61224a242ea65bf84b4603626e9b988ea0badf56e21deff439074eddb156e8a564cc06edc81d3216deb7331237e4326aab8351495f6922757f57a04e21651d4a54717ba09a23cb2d2fa4a0565def1ce8ae8caae4ffa985461bf05f1e54e8ac6bc5c8ac81fc59350854b551168f1df0f51164a6648", + "a5e9b81c2041fb3a5b7e8030bf2e5af3fe4a7ef25773e34157d1d28cdfe55c34ebe8c70b05c86685d5beb3d134800ae6957c985f1d5fb52141c87f5965f020df5afc424421b70ee81673e76896994427973866825f542564133b4ee0b804020ec2159c70fda56d7b53557342ce8679740ecfad30cc2be96ba77144b799113021f42385b59aee61818b5d50dabefb01ead8fc236b510495bfa88c0c19b070a86f093e6575d5ea8ca035bd2fc0f694288ad875aa3bf48f276ef0564fdece604ff80c0d6e13842806bf3fc42f53dd5faeb4a02d4808c804f6e4a303c665993a8986c6083d8c17a4cee1479ccf26bb5f01e5f523ec82ba5947607102cad83b91508d", + "1e7ddac9b694220def2a4c44149aee02fbb5d86a461f022c352ef51195f40a1be3e1a711bc1e17bf6f52239e8a0d7e21f3eef28791f97db58672907b3305f75c51710689b058d0a43d0144829d4c361f5f0da4fc0f84914c7c6452b06cd23bb6b1591622f60b74dc3b33f7101d9bf3c749a63db8f19f3af4aac2ebfc01ebef1498bb66b778ea1c00c7afe5cfd31dce44e4f5ee6c7ed6019bc38bf99c00d66f33e25330c6e2aca362bb74e6dc25748e44c3b068d7fe4352df1f249b29181736ce5466d80c970bf8fbb7eab3f4eab59fddc164376dfdcb64f64103683869b20e50561187515cfca112e5bcc9d7e1e96200ce1605583947e8454f24397694297481", + "35731a254d9caaa734d96e4f854b341bcaa010e367c36b60503e9e0ccf41e6ea260fd668d948b9851d22d8c041f04a2d07fe3b10fdbad1395a6f38dd221b9a2b4ad5a188ef4894d565b22a338139ad61b77852a5ec87e959cf5cbbfae13dcd123360c9aa91ddf61d725439b3e3b5aa68376eb2e41870cad9c085dbcc6acc641d1b12c1a74b0dd84c1027a26e28c6d9b7c025a873efca08c7ed20bc6811213a1d99ea5ba2162150b200107f5397efc250d9131c056609c2d7cb5b6ca62cfbfaab2c0a271ec118c2019e78c0b5056a0c9f354082641d6cecbd4f7c828b6755643b1434bc247103059ffd2f315f937677c10d37628553b241bf7deedf9df11679ac", + "13163dd0981acf0a1a0c7c4facaae01d81d3e600091e1c35ec5821c083ebe1589f532191bc53531ccb8fa031b2f3a7a238dd7283903ff5b2870396430d6863280d011cf30ba68f5a08372d44d34cbe2a7b2b9985120ab92dfcb08e1eeed5ef8a2b41faa16d881f9ed7234333d17029f88630c8548738d3559a440544cb9009d93b7f1341a039b68c9fc6c391a0e49168e2733da1b5a53a99e3b3b5ef921b0b1d4998a6dff1e3055a4b94e4e9bbd563de26ec90110ac03707c6609287a1f830fe1c80a908d83ffb20b007105dd9a611ef9b5060873265d552908f64672f1ffc498f8e3ff089cce566efb4d3b7af0afe2fec29ae9ad4645dec0c5c8a9d3db4d1cc", + "d054a8f9d6356b32b8f6352a33fd07a827adcacc01536e43d4642775576a8211a263455d8de4c2027837d913ee4e67765dd4697eab28151164703e90cca341fa2ade3e688320c6ea3bc8f9da14e1d842c137b2ed19748f5afc4620282776f1d997ac12af88a9409942c5e93e8eba670559515be1a934ff2c300e1769f947936fb2336b1529cec82df1997e441787785e8792b2b1f7a6edebcbc9e08f73ce108a1c1a46c2fba82d43713d92208cc92bdd330a493bec9bafa98c66189656eaf7da5f5973ba57317b582ac35f0a228b347ce5a0f5a1f3bb07c8dbb7a6a04656c66a3bb156117826a9750c0a50e6b52cee0d2d8e737f0f3f57af9142fc2fafa7515d", + "d060913efdb40c1b809aad8812a78bb4769a77d370980df9f4c02d745b85cffd31f8607a398c355a1ebee13736205788a5edbc7f2adfa5a49977a62393765553a686d0744c54245708773515b2faee04537e262c2891f10e9cd8ee67b2fadb9f47fed7b4b69f31558b8d225f7c10ca8939a3c5970b8d8596d7c7157f83e582c7ba2e8cb7f23fd2f9255cbecb9b960f07ce4c1dd9f25ce3cddc741a0bf76883551663035b1b3f0f28c024ad56b592bead4964094775b9382c07363054a6386d0ecbcb0ac3983dbcd8bfe9675b748bab4b3006024bf422a3921c3bf75669f44b6726f60a6356330d7d882fd584dccf215040cc2c835113475e98f0c2a1aa9406d8", + "32c1955cae30abdbe0a1c497171b5322fd15e0ab49f08d3c8daa76ec99cc0b3a1cbf41c46be4f5a06dfefcbdd9e4c189f6dac31e6c35c13a105e10588563ede5fed600efab57449e1c705f2bbb95dea27059728f30b2ac28d09fde28fb225383b66124ddfa0a2f2769d84b35d8668b16c604385ac56ab7528e32c3bd62e4075a223a700e0013e98cdb96eef2922a9c35b1edfddf7908c24cc466a419ebccab85d4aa2260eee6b51de8a8a646b663da62d2063243da0d6d1ddd1be7c09a6cbc4f35939bd492067af9866b61aabbda7fbd1e3fc4e67ef16dd225debc75fe3fadebb19acf798dc2b6b82cb585e404feaf0efda88058eb00fd42e1355a1dc5e92244", + "6f8165f4ddfb13f055c6ea57e3c56d38a1c61c43d9e3c9a3abd46fc0e8d2b1bb426eb863e60fe2cebe6c5c0a361816dbdfaad2e03d70bb05825c41a6b43969b82989265980d6c7c7cfcb7ee8cde0755248f09176d3a4bdaf26b18ae2d8ba3ca4ae3be92ee943ec9d8a03394586553904d73938a174d537291c1c119f50e71699ffec05dd5b7d63a9b2cee3c3b58c2765395d703fab1e6ebfc757df70c55d44a7974da65dc181fc54efbb32b4fb3326653e18f18a49e9f8b4c6007455674877b9e4d28dfda4256d6b76fdac4ad9caaa9c2db509985cb3ba5b119625c2592fb260ad8ef60d918600735f99cacb1e2a6924d257c5c6430a1b4598608342a632effc", + "87d48449f459aaf321e618d721b5191e898ce618cc4d77e2498e5246766ad20029cbd1f4e5fa0475f8455c865b81b80db6588146688894ef78589fa6ed623c2abaf86f7a56cef0d04e4dc3c147537f05144b63fb4740a7d1b189e8926980c033dce093cf02ccaf5e84dff00df26f9629740780facadce00ae8223469254619e70d517ede26cc672022e99465e57958c2ee56d284eee853b15f82830415bc29942f702594f58a4842fdffdbfac2afb893193c3eba72f617ff309c8d83097814c6245099bedd45b97b9af152a96626ec821fa5109728a4ef11b92305c916c291941ef18d1a50edf2b962711d8541c5df9e7a8aedcb51375480359986802201567c", + "2add325088eb47fa28ea97c16d57f09e7ce8a72fe48169e0777a457fa68d44f20491a8b11a1c76f2bb06f3fb6081b58c7efb5765d41d04618a0fd7098aa189df863f97526443ffadd6fdb162ecae10515dfdc2a44ab2a5b68c4e3b6e5c6153b3eba950634aa5596ea57d146aeef6925bd3ca20f327588dcb7e4c4b7250f7114ce5869853282d0e4705f0ffa51f94811635dbe26e3c7d1618c875b4fecedf396d071c315384dc9cb139623056600a6d9923c317f3ccea83587fd75d911a22203426c7aec3b4f84c84a012050f83d9598d009bc33bbae62ebf880ba4e048d1e00866c2d17d17cc560e96d036ec13317e3cf7873360a168c4ab88709ac894eb90ab", + "4d6cd0b1bfbc4e96f7172d00e5c639b2d175c348115d2c522f04822024311b9ec892bbe3fc9f22d5f85e4cdbf46e0edf7412df742990e44b3db3d877b221b93ca638c88bdba8658a3f0cf5a3bac1ebe2f913dc6b98af414c05e927e29b341623b6da6318cb91dd4ecfdea17c2d2d170c6e55c202ccf4ae5c93af5959d66d6f3a7772772f4cd224a9146265f90ac6f4eaed354c10c8b825d29241fd1aca0c00055009a441a32fa73eaedf60ada0f0f0d08ced86710cec7c3d623c972336179dcd9854383072228f4d0fb8b827e5a3325bd2fcac64f68add2972588099e2128fb0865ae25df6685f45919a800be9b83c4090edf1f4c85ccbe52c815bcd14814b9a", + "d73f103211a120f7ffa4ea219beaded6f87ea91bea98c3ac871262ce0afddd75ebd57fb64f9d053a3959cbe83d6626f5f1cc740648c50e0bb11d2ffb66464e592afffe2f2134a7eae704c27aaad209a1be0d2998b9ea275063599eaaac69956e38850e4f4a5d4a3a5029e9888072f2261ba99f71eea1e51b7b74c01f6262db027de4085c875b8603444c120b4a5461b0da0ef4a531931257552cdcc61f381749b94b0871d3f3be5d927d3a2875188dfae4b10dcf5f1993470b868a1566a94e490e771035a64555d6cc526cf1cef7c872751f80d0e64905d6286bcfeb176c967df8546dcee261b51e8dddfd4760afb5e6b66157fc4f8c9ec12d18740ada32fdeb", + "a0e04d1b9578d92f0e2ee7754d5be05a2a5efadf6abaef8d32951152f8feae1d419fc36c70365c5c9b788b51d773262d9d0e61f13a67ab63eb5fe1492d113f0ff3ef23d1e61685a506021efcb139d3d80e737e0fabbefbf94e1193c6c0dc815ca54b2baca2f6a9789ba77031ab702e700471241ea33aec547c7853a3697cb1d849790e43e113b4b2bccecc9df3292f8ad8cffcd26907abce2b8ab4ff135ee7b650998c702d41934975adbc3805d330296b0783646aed26c54bff6469599cc624e619d477c49fc25d3cfaca7c313f21380c0066f6aabe449860496aa300ae9804fe013083e102604aaf79f49dc2220df5a9c5269a4227ba08dc1fff3f635d7449", + "350cb477f697f0aaf8ecf5b55eaf08b03115cf958ffef31a54f654ebad70356f1ce16d11e3ead26fcc6d611682a75a9c5871a23d19eb86c0bec0f5e7d26a25c1e4bf967e9333220c7e8bf97f868ee0293d00ffffecdf7b3c05ee2c5e89791ff3ab2d38c0d62bf0b869f805da4fa61cd51d7b5a1917d9a4fe9e6d77dd9bfff41b3efa6f84fdab7175ad406300970323978ba4bf6dc3294ebee34180d87c1db0d7386fdc5c465426b29e989583669b6bb3223f796d7813b54c9cc17c1b8dd19fd6dd0f859ddb392aa3ba13ead9e7f5eaa1cfb3734eecf22a4578abf48c980cb1988d826bd694b9a980b7d1788aa727430f517db996969fecc651cfee2ede4a5f26", + "cefe68e327ae9330f43e9a9e8c542553f9d9b7ed784419ae87b849747f3f610c673ee98ffece51110376e9a3fea923f73cb5800d99d6552475baa46e60f6905f2b4d01ade73db4003ad6bc3005c09fec0c47d9bee1142694ba29c610d744e0bd1fe3340315fab87ba7777d24db52e26483d0ec473917bc8b19c725a45a4f46848b60e071213ac9b46379164adf250f1e315910b8122bbf1a6578b420fd20d4b3312a0802121d683f8c27636a0060cce3a706fd022908cf95428f85918534975981a94a7d8538a6f2e40e96777656971fd7ec027a4b4109cfe25d22a14fb7e8554741027bf7ec36d919c330186bb00691964754b91631b9497d9a5fa98b21ea57", + "ab416157980a49ddb1c5a082c83995652e460910e7ae139e322a5a4c343859d2c5d071d31415357ef4ea4b1d4ae5976a5908a7ff415162d33d8b1a639b7f55394a5bb2ee97fd2f0669e3219bd8eb398b9a2e100aca9a25eb8bcd779d40e385f3dbb0c7bf6c4b4235c38dabb568c7f44da74612fd9d0d871ad24f4c99269ccab4cc5cc82630d7fb8117b18714957f6f65a0bc1cf31691ad553e255df12883e774c71509d16643cb88b3eddce57b59f8bd32125b0c7ed8388a429224b9dffc6917921c01651ef8c91cde956b4530a0e9f8086cff0d34a2d95d9823445099df7cab7816164fc766554d8c683d9a57a1d1b4588f2c6559a01b41f1a4590843d4fda1", + "1099018825498f385cb4cc7e9436be34e5a477ab7461bb32ff492bc580eb75c6bfb4530d01ad279a7995d02147b95009d8d996793a8b1a805c5c22c680117573919a0912c0dd4797c8baca8ce2bfd2718d56091a215bfb99159fd35b68bb85a439546e9f3adcbbfd962dc44cbfd792ebddc71185e879ba969c6c28182b49d1fe0318d35d0e77cfb417b55b122171839236c44e240ae6efefc078ef3d9caab329cd204e5c31f044d840d12e70447361e1dc0b48d6330d2b761d40d2312f0cdbbc39a2f2d6a8773ed26846f1e2c0f410f79f825433f5c9bce065bbc70982a7f3c4f71b99f0d89974b2901406c040ab3028cad4077b5b84d0348f8f7f329d2977e8", + "59ab489e75cccbb8cc00f1dfa118b367607a01f74167c8bbfe4ac08c1848460f3320e3c7e45fe91b6743e7281de5934bbd5eb0e981f683b13f0ea59a6e0e77156b6ecc2a9699d611921197344a20c6ab977abc433d90f5e6ad8ad00196b0c5c4630cecf94575480ec52cd691878aded7ed26ecaa1d5b60a061a246c5ab4daba4d94eb78cce6b48d2adab9f781cc7a0b8cd12b92921b968ce0d135382a45d0b40d73baf52f8e1c7f95de92bcc059cddf61cb517d70ae2eefd52043a1d20124240c303bf6f961c937f11aecd0748e869c1132469f89ada8d127fc56a93985e03047dedf3beca47d202424dbc2b2b2f59d52a5ca699dc0dc0872f0a350ae19dee35", + "566ab797a31c4570dff13fd4380072b723ddac88dbc3f2f3813a1f7edeb0ea1f43811c61c6c2f785669b5e6aae1dd9d74bc6e8d4589f1f657d18d6bb0ac9465fee36b4273c95f3e97ce9810a603c31ced94ba8d82e73f7aa90ba80d08a388bd82a274c0f3f13995730c0b1e4ed377682623c6b151fc6f39fa4481a091a5b728d0ee7ecbf33716939d368fb5347ad4ef7fbf963a7e62cde89f9ba607717e804a922180ae26190014622de41aca7897be656c8379f9fc65e0d5852a0b8394cce5b5f2f9228aafed8e20ea59a2694e0826b2be7f1a71abc9d7590fbe0cc6850f7fa99d7a565769c05afdd30683688536ab36f7d7fde9b461f6a0f8d5c837a50a442", + "8011df4eeca2cedef29fa1186cb7a2567834374c127ab12d7ee22368618c34d81730ee95fca903245e5071cdb621f1c9561f3d17fb0282b9fc74de0262a1263e28f816055f29b0d44f128fedb8984b037c8278a125cd610e0c234448b22c34d2ce509efb51b2b4de9ddc540db005617112a5028e7148ed49de1cb19390bac93b7e650734c4fd1c1b1873abf2c9bf8150e157820d9b1f5235b90427b566c7fe72bcd83bff623c08a850987bbdfc2546c202f643365df1d2ce2ce0109197b6e57e63518b9190ede5a24eda0fcfc1fc1ffd153551ee929e8ae5587260f7316a4b9919a1efdbf39a572b22ec9b4836ad3bc98e7c5ef1d4718a843d8b39d06af532c2", + "9f5780be38426404a633048e33f7177be73194aa75029ac658ac2db5f4f9c398d448f705a3ea4b353e124ed16711c61e12b1c70fcd075829a26b1ba0521d206e7161f48917fd5560f41afca60afe2071495eaf150f9d8ce00a60c1744c84b14c082c84d4ba1d2feccd8ee12c2dbb5dc944a9f2f25e62ba3c5652024ff969c4b480ed273dc17c68ede91c474312bbdf6b9792fc3108b3f53e7ad2693933cc337a19253b3e82837ae76e709ff3563fb7f1b4cc8445fe189e0ae18d4d810f422436546d16dbbb52d49d4b65df9fdc2f52c9f47a81f25dabfd2cee4df04609e6d55af0fe6160fcd9482b5d94743c50fda8fe5a3335ffd7827bb9cf845eacd0c7ab42", + "4a732dc26d02a05b1ef81ea2543795c42d201421ec881f9f7262da28f86da4fb3c9aa7b63879bd2b9927bef4753233e046af003f082578739841a7665a8794b8ea709eae548d7d30e98bbaae1ac03faec7d89de5b9dea04bc39cdb60d9fb741e032d166a342769adc3435bf01372294ece57970005372e8da1ec94bbb003826377add365f40609ba5d5559f6d79c6e8610796b4a5f9293b0f91fd9501a3badd6c5adbed0a710488ce0ba74e8dda7e2b585420d950020a83b3573e7a8fe88b45b0cc39b01977a444a543ad5c0f24e8c02431f607bf19ee12c86a2cc9db73a482c0052d426b83098b9074fd94ee98150ea1e4d6478ab79f72e5a3617106dba2d62", + "68fd088af439ce22cb40d2203ae38c37f0532eb9eac6f9e0ac057f389c16901869235721744c22517ec6c1e087ae9bd78604d10076669d36c36438a8f5086fc1d89b94d05636c3991de040da30f8798c4ea8cb8c2a944ca23e729a3c445f4d55807c6bd186a6a4580061919b2c096f18bd65c32c0f5c9c2cd1d2db5ed69f272213a502e982ca4fd1e83e1632b71926a58727e4e1470eec729b9705bf04380d4dfecd6821a5e1afaa88d27332e8be9012113d7b37cab521199eb2128548374c73a853975a92e039e45e2a107c15acff5340a2b2af8e4c0d96ae797626b28f85d2b1961b34e3c6149c834d30025f8c388cc85c1be90b4f25411bbf34a9e37716bb", + "3dd68589b51823fd9dee731482ee3776af424b5d92eee8e2d7f413ff7c3a05e8e153be9e6b12905597073de0f02d49ca22a15a65863690ced853c20a91ff4f28a705811eb2820e9069f0069d3048fe75060096df81cd2f8b25c4d54d4268b760cd4728e0a69b75c511e56d1ad838e306d4333cf03cc66c17e2d282e4de2e32795d93c840e774cf5452a4549dffa8403db9e66c178ce4820822af2e1004a74ad56209272aef02fdbb283af574dc7f164ebe7fb632a17bdec421e6e84f60a70c6b12c675a65a83cc0c0d2147f66071cb44d86e5540725365ffb0e2d00acc1272031983652d219f373fb90c81b7e54a2f1ab3cc7b80ab9c69a055b58fd27059a2d9", + "8615f7053a1a2cf537c1c723775ebb975f8e2aea1d40759db5e45da2f8778326011274ca13c700bf90ca6cda0aae875fd1f5b49d4ded8a7a6b379262b11cc767ab4a35828cd336a6b3dc0a26e8b7d80f0dab1a2d648a8f54258070e0fd3247cef6309b5f81f6218c4f295918e3afa9c548f315345d6934916dadcbac81b5c63d1285b94c7bc5d4c0e27aed663cf2bd5455bf1998fb7c1c1025ff5f2ad687bf433f85857beb4b27d796c9be99a187576f2273dde61448de930641c1042c1a667f589b280ca9833371df89af4dfe90c8245cf5f16a0f3c7788ee19cd21ddc1ae4530c8625854cfc79ed6657775d3402d677dff14b0061ecc828477641304868620", + "18dd832087f244269452b9dc17709cf3176d46828b65ad696b5d313c6d9bc0e6a6d61f637ae35cf1f706b2d2226a23b50f275ec4e5f06798f99a72804747d58de5839814df3423cde21115ed5ddf271b3ea784fe2d7fea0a4d1509174ae3972f84da8168e33edbc482a857ddc6e91113b3e32ca7a3baf61c12f5710d9c750b85ceeaca5f17e49a008d12def118627ab01935dc34b707459093e85c35d1cfec6e9d347f79d955503d461fc3bbc6886ea84f1866783e836fa8e8c799eeffb2fc3b1b726396ca5b81f849f3e2177e6cad6cbbbc5a3525da7c9ad26a45ca27ed31df4a1f518076d4bd516b28c9bd3e9d11e907a1b0f199cc9af38e16002ad0f265d2", + "559882326786667d3d48b6397ccb36dfb31fbdcfff273811c533f1ef5134efd2c971cfc1854cf26abd1c81f4c8edc03e01b10ff6fc4d7dd72653c4b32d2863cc7c7cf8fd11db91ffcb95be795497cf585cbdeff94344ea6264b2cbdaf532d065db432f97c113d04c08397bc13ae39f65b40db90c8de1617087b4a56f8ce91b5097b82f356b26193f1341cc9d37d43c6a5c72bdf19e7016dfab1379fab7ed6d588084732496b3f37e3b97a8804ecc934ec5346f4a1a0dbc22f5c6a37edf818209695f441c251c2cdd5423355c51562fbb11d1eb4c437e885ab46b44a58e5a04c208a89901c08dc828bd430c07813a8f03d6f2bfa2c976d1ee575061d6338084ad" + ], + "carrier_wire_sha256": "b14b6b08d96aa6d15159ecf8d4c8fba8a55dceb2847610ce62796f48ce93e35f", + "challenge": "fcd6d96035b6c6631d198334baf5d52cebf3f285f131d7f04af19e0adec4c61", + "inputs": { + "h1": "4638a1fd72f205b157b62fdc8b60136acae6043570a6ed432179754caa7f3381b66f6d73d1ec88b8fad20902734b2af62c8ab781e4a892aa834d57533e442a6701cf8806da1d1c258c26184968ef58df1cac895afafa5763701165d6aa04cc38033ae37260fff0fc46b97168cdde2d87f2a08e727210cfa6c7100780dcee6ec0be29feeea8d52050191535578ac8ea6af24cc559bd8f8172a6423240be0e4575d69b1b45d52cd33dab22d737740e94c1967f60f7013b9ad2a2fc0b24398b0687e0bca15d176a940e15945657acf745bc48ca1e033b2d6238f0f8abbb897e73927778eceeed7e53e9761e49b2653aec0ed4487f2f8a6e3a691529492d33bbce91", + "h2": "4d91da2d11aa6874b7419abc7d4572806ac7fdaf6908646953cd164bf2cec233a8d4f8ed0c93db44993b15e2cdc8af28dca2d0d416a7fdb07ea63d0bb3d5f8edd2bb4898d2f14738b231b8c1d8dcb052e8fce682f0fd4713adc78cc1d30edad355c6509ff6ccd62de6fb6507467c0a692b45f6e26ea8bcf506a38c4620d7a196398fe8c64e82bb964fa3535945cb7b1c0fbd46c82829913364cc6aa4c4d848a9797f8dcefe32c60f478587577bd50d7d1349499c44a6ae68589030173fa120703f3ef58186341b394ab1e42191734f46e678558323e2b870a815bafe6776dbe97cf29ea0fd3581ce6220093f84e5390ede274e67b1ed92eb2687a1e4bb4efefc", + "n": "da48ea954fa9a510bd74dd7273e047a5a1fca96906190d9641f5a2653a17163d7b888d1c524e82c51a3523b4c7cda45b4789134c3d716ce4e194cbc50a6edf761da800c5331c4d957b00b84ca8e54e3fdb481788239dc5a9d6af31b1a5f9c6087ee10286bf730ff2b9e9cf294088815ffe11faa980b5a735717c16e1cea0835115287528b61902a9320d5445b81ea6ca2b67eec3a9224af2bceb7993ccd2f637ffc64969e26e98b7eaffc317f8c75f001f0e828428b631feb6e4b6b00f385dbc0355d025f56f48818b40bc1a4a20a61df2294c438566ccaaf1718da504b67361dfdb034da9cb9add2d3997e39283df736bb7fe80804f1cfb4ddc7074fdd4b959", + "p": "79659361127f482628ce93d9f934757a464ec2c8eefff3c6af1622afcb081db84ccdd3e3fa5b53e3b0740b456fc9a1aebdd3985d397e6ef75ce74388fb830425e6958d4a0c1027a467029334ce62e30777f6540b062e7c014459abd8bdffbbe0dc9ac96f3afe6175fd99f1e7ca92f98a1273817438c78a200d96c3217620991d", + "q": "73143e381ba52cac992f5608c56b67593e0d8c33948c13614b07c6eb1080c5c4d49c6c747639d3c9383d008651d857f4ffa8686f818e949f8f074db92e2dfbc5db353212d6b14045bcafebfbd0b235a71ec134d23dd3ec15a50c5f9377ea9f0fc03c461e04a1aad74f8153798fc31784447cc2d88fd9001590cd498a1e9e2abd", + "x": "235239a581447a6d9c9877145e8225e3dcebd47d9d7298a7e2ab80301e877a7f367de179e32ee6f221f026f1e85021a04d550cd4fc4145f07006d82a8763e267ca900f972f4a6307e8c2a6c3ca7477bec2e2b2c7c3e6494d7a11b62dafe376102960350219d21cea602cd5fc6b57a0233d8eddb7a91925d24c759d3b0c19223d7716a06a1ee39d1149477cfe39e80f715fe9e189d46b517fea7be35767d8ef3f7ec03f6bdfd964a52174ee36efcc0c5e88d4c7067a6294093d29abdad1810fd8071dc0a17efb3168c3ba76712d313f43013b7aa0b2e444eb18b7390ff89fc8bb70c44929e3747d534345e94172997b433a1abf26fd983c8378f8d33c2a2df782" + }, + "t": [ + "14e69648e7b9958049afd2cdfa4645e8a0083ec11325e32373c7e05bdd84c6b2afc79f64e31ddbe0b1730cddf0f88306726cfe85adc51ba166f06833d8124f1a9254f42c89c16f7f4fb5d04b35f6dc8b33d7c6a8fc535fc10f3b82804d193708307ae624bc9886afbb315f87c269cd9b0fb4ca77f53b89477ad5f00d6fdb60f40eb087f58c206ed28a3f8b1ac5283a36e9d3cb37d05fdbcd2ac2c2e0e9b0bfeb8eab033d61377a80248223288049156c75508c4cc8666086923250cc8cf47a4f69b4eea460fda9854c1141e8fec8a6ce7a4d2836217cd8f3ae446c967617ae04da924e039ea047b1d48675b81f8ec4e13c5bfe936413f816e10bbcf14120e5b0", + "6c4d98751f6058db4d3d7bab121c3ee2a3bce44d832926c1dfedc79f52cddad942514c78f2320034cfcd376a7018c1acdc3ff85be56322d743f9daa9999d4c7c2ec4129768d063b894608c34d236671b6d660dc99072830fda97b09afbe4d8b05a8f6182e1efe08adfe80372919df3fb4ec389c17c70f921e461b9b21cda8c292ac5ef1fdfbbc6e56da3da0664ad1311fb807936f0569e6d667cfcd98b4aba01306967f2e876fef45d368e04b57437a25b69c13f1abe041fd93bb3f4c7f20d736504808bbd30be7435221b232eea955c93009ecf8d226ea1b255ea3e216f253ba309f83b20fd898f9c3c3df63600ac00eacf31fab2d701b7fdfdb71dedf3c04", + "1396d5b3364acbb3bb6280abcad8a07ad6174d78503c591d77f619d52113bbfe0222a08d05d77a4823a3f913158adaf27a0f1d328529ac5794590afd80f07258b2cc5873f0fc16aa87544a311d37338478aeb405fbe34af948f5aa2f65881948b8ef15b667e65188a26f91c8ae00c6de140998927fd303302fdf97dcfaaa2ab86501fbce5deb6701ca1689895148ee863d62e288fa214108e520aeaaaf402a72a5bbfc1aad65e8682c69259917d68cf082d608ff8446aa37d2aa90f1abb47fc71470c7528e40e20ca327ee885f72d002a1c93513a0f727591df2c55d1ec234feb8b96ff39b121d6b63f78cc57b8eed9fc3fb047695f53b7b551c119c1dccff57", + "6e30f0f5112060a1cafbd6b15032d5a21c78335f235d000c04904a9fa29a58ad960f7e17a49f6ad4bd4408b14cacea65bc581a91dbe3709442ce047a260e2dbedf8526737a2f88ae8904dc085e727d83679661821e347d5d063382bbb5a87baa7d8f5cc358f94b2ecb3d828ea4c01ffd52e9fe115f25a06d9c4a06608650a80022f347f23c0c290dcee8f16b4488a4cb787c5793e747d466916d953952a68e7cd6236666a8a08ec5c392108fbdf569d3c635d28bad578be7efbcb029b68bfc3055a581e4324752f813400d387036779e34efa1575cbb27df352e3c14b75332a45d75cb24424c9aa94acd52482fc4fac30c3c5bcf6db6c324df35a196aa77125", + "8becf54cf60f08efade3f58f2d57d5a256aecbef76dda36a6c981ff0876f7fa419782325e47ab07d8eef8f00e1bb6ca2bac36e4675b5f3246e7653a11869b87275659889570534c0e78d1b3516b3277a0c85657b6b77c36f7822b35a12fe14dfc3c092c633475859c3f016e96e2b77661c4e9889d7e7c2db93c4132e3a12c7e78c017b4a4a011b3ffd194365b7a1099bc35c0cc7aa20c7e6314eb467eca47110409e665e509e9c7d10748efc61c3e2acce72105d32713703df76861d7b2960eff68cb524dfd8c376af913887a7d941145626ab3f1572ff5a0534e0c630a505ffcd763721799b48eff487b378ec8617a49df712a8b01c9148209fe61d6441efc", + "2eb4ff17dac4dbe1e6159f20656145a2cc785b72a0329789da596011c76a2f1ff033071aa94c89eb8f74b7e2c76d5795cce2bc8d57f89f5443be5091b0e9cf70b24737d29b5e2b4c27e2e417cda1b167897a0237582bb72852256f6ff5e6c6a2ba1841cc6ce3994f8a48f1a5ab72a4f9af0aa1b8a764e4dc3b3c562bf421aa43d7bf00f820c02dab60cc3c62bdaf2a9b53f83d376781271197e104730c15e71add688851230c74f0cc29aba2b78f22e624914105b6b0ee4c9f4fa0d8b6e37f5b332a45741f4797b698e99eb192d1b35b4136535eff3b724be5ce0d2d67b73089b7e8902cdb8676aecc1fffa5360681286925fd51e96c0bc3e539276bf469d1d7", + "24365eec6ea34401350a21150b000d163415e4c06be945eb6d634641cc66b09e766374c1844364d3a338f6580283df7d318c22d95da7a9444d34a59ff7d0357f89a97639b1d22946fd9318d4c9b98f702a22a4b5a74a49c902debf8dc12e9ec3731ea893003b2c7faca47d63df6b14ebdbd052e9fbbc0224df14fa00bd643e1a3a23b2860e102bb74a683da4804b30b17825d1f94972ce84b634f34d5d8aa3d2718e783835acac741c40687c132ea3868bb2fb33291f90ac185579d4a12d4e7c4f9f3baecf2875a338ec5c152923a0bc5b3128949891d7a46743031f124c00774afb3e6ae0c0b11c237be2996bef066f9d71e3335af99de4b286fc07e86216a2", + "4583a8cba02665c7c78516466e3068c0e1df89de4301cba4bd4fc16d948274540c8dd8b90509121d89e1206c529ed5fc7c262fcdc11ad834235548e9d9cf4494c0e6cec1f1614423d5a165edbf2fc64f892905ee3a6c1c1c61e764a4f62d3af13f2d422602eef597679f5d9f707fec3cd6258fed04c9e50b68be585329b65227acd3bed9c9f473265917fcd65ab43667a818fa8b4c8bd1555b31638720d10782057da48793d0fa657ba771c4601c6c9a5109135aa345b65a69fa7b79d78a91476c500f221f76e4b1ddf418e0a0f5faa431f39bfce6b9b331cd26e5d3b09dfe4337241680d9bf90aecd725055c66bf29c580adad19fd1a2fd4e2ea69a1e653c8", + "efc5a9780de5202e93ce3928d0e2192484a272a606b12cf6be5c6e35aa4593d06da09e591933f8832900e59f2af866ecad4cb2b4a0957eefa0444bc0975200012859c3755c091da8a578438768d12be06ec6ed60b9c4c57f6e313615bb016dea90584dba56e86aae453090030940a7a81386167c0822276cd4d751c6d8777c94a28d1a720ec6a3ed5e45c0ece76dd8dcb52e36cdd4777d17a279831d0267fd259fb7ea30644430ab8b03c4c110119acdc154f9a83db54242e6d2d526a17b6e84c1ba7932a8757c8adec04ee93b685621c75b30b11dfd9bbff0561a19ab1ec48d627558c38e9761542749c1f25ea8643ca88242685e6152adcb0fb93f0c7342d", + "21406f0531d3ffece586bd53019e459f8bea062c5d391e8563b17f7f36871659468eecdce6e87338a7ad7b2dfa5bf14f8816186e55c8dc614bb0a8f3d43593a27f75e7e9287e0670f9a3cbc3e5be708b01ba9da00424445916f35200c3c7df1a3c87c4964949ba2bf953470f135f42c20b8a06290ef8b30348721741ffd2eeef11ef429f81123eee63a78df9238e81f91bb8db743b581d302e2957bacc5710b9d5914cce64b874f1754aec57ba402312b3546326cfc4f768eb0c664d556c8aa130c33323a0039881e4df53e044ba21b3e2173d15c8546897393b4e1aa71aca3048a1824369a91d855fb0fd9c3c3e81d502cb50bbcc57e4ec66846c314a3770ee", + "4046c8720bd884dc257bc324f83dbd71c97f452bd425cf4092faf70f0961e6a25399065f005abb2d951fa8d65478003a19376bb5d51d23d8f009fd41058cf3eca904ffea487ffd39e6304343bda05590861131e5b0d7c485df415a000b2eb8cb3797b6d4b0d6932cfc68447e2ac3f3a5e8d2c84c2cfdbbb723c801d9c7df628f880d745029fe80bd6913282005a865072ab79f48ef436e13273c4afdd605f0500249936669712476dfdb5e089b9d9ac32dea2280cc3949b2e9b79d5b9cff2ece676876957574aadf795e424173bed448f89aeaf2205fd2d7a4cd0a8ddbb71602152758348956f6b90dccd6aff55d8cf422584e7bca13afceade01e600cc8eaf", + "13675687edb938f239a651fb55550a8edb307f6ce2f2986c132c9fc650ba97edc5102b1feefaf4f3691dcbd3c1b58bacfffb12b8f0e8a471db9e3fc0a71763c169de5c7504e544e163bd3b60b51270998ca5f8a34594f3d998ab98e486ae9f42eb59e9a731a70ed3813da54c68939261c84fa0761d2a951cf7f06dd063135db29cecd988f9dbd8e7a3e02ed8f6f83b3580d51ae3c3b76d102155ca5285c18444d9ac20b33f4cbaa25526d8b1c664b7394215da7a5b0717d6d46af01d7e1d93e1266a16574550f431d7f2a7e130506faebf8763137bbc7f4ef5922f383edec1d4b6b2c2582f974010e8e9601af28dc70c62807a17b8ec001b7821d58a2ab871e7", + "f94e78c240f90ab82c22f98781f9ee37ec1980b8408c82386a0612206285fa3273d277dbb966d348274e06d90ca75f746f13d750271467ffef8c236e5d295f3604ae6f2b4452c750f3c57c6b04213c534464fd059a68be54b6dcb68a8f5ed35b40450a401a05e4b16ea381ce2cf3e58aeb4ad0782acb72777913149c3fe8d02dcc2702c17791c457a553baae986b820ec82994c8eb658ce0a05094adad8f24bc568775386cbb180ae4463ecc92846f74c48aa3b940633b8e36684b85502158e4d42350aeaad4d9156020d5484bf00f187c717da19211c3f4e9e5109295d96090ddd8a71d87ccde2115c874c9f77102380eeca7857a76176fd06f8e731815711", + "23495242415f3587937efe5f397f9f482f77a1f107f1291947edbad775662afda4ef85c95f9dfc4d1a98e8b34dfbcd5702895f6d85c58a7b3337387320a73877203bc9b5cbd61cab8a797703b24a07d7b558f7d44678578738c5595ddfaede5166ef8f4ee7e6b447c1a3390cba3be39433d00b82a09a4321e2d7bff66be461616bcf4ce2b89c3501246eedb00ed6a26edf99d4d12acf00a08011804354f03b68648b82b412b4cfe0896ed96997215c6b40f1502242928ade2265afa353d70ba3e076e5e87709a68da549b87cf35371f1187e253385de88ef9180b6bde94a70eebf6291b9b63b7546a5737c7c48ff93c33fdce05e119544e77bcfe5a2bed94388", + "f202b7edf12065ebefccd7d27e7d33d6c2eeb664d7a80cd74ea56ddead38cf963148a7c106c93e3472f7b362c0b47d2671f710cead34d4b0b670c593c7323c0776f0c591e996396f8b74a73ae8b8b6d30ddcee1c7d4ec4222549ce3472461877091a544e9253f8ec3e210a187100eb2ff08e86634364e79f64ef39e3da3597aef5d224401102643188c945b9cb3cf5468be41e91fc2e8099903e65b7065534d9d2d28f304be022c1554ed5c37ca9407c9ec2216e316b74775459ed1b5a1d7f67d6a823f06f9b4b305e827e8df95c271f71cb1320cc08864081543b7322140eca6c0c274dcc8f7d9874b7f7d67148d65747cb1bfe5fddc34616ed063ce8c41c6", + "2a65593062b37ec2ba60c4a266633b20b499a70ed4b95da44714ba8d3e20d4527ab04b78d6aa2f9bddab587bfb22645352995bdb804db2cd3ded4b1e93064cda4cbf9fd7eaaba8ca766b5486f52be26a1a79abf7863faf25ee27fdc3a357300d0daa68f0fb05458860688f6c53438c84c53497cc5161748f9e6d7f4da971852fba002bce0b76a11357fb4b4a67be7ac32a85b08043d05901e6e0938f12ad06eb155cf47308195620bf1adb5d535144d9e84101ccde93065a93cf518d36813a088833efd1a37def5ec292aa650fd3d1b143a2baf1c2c58f5f6b3c70170ec0904d2e2137d402b9892645147275d6126cf41b1434db45fc49f501ce18833a78b2cd", + "331536a64151f16c89d62b01387c31623175660d1d731f24d201f8454a1c28f45af0a8e14fc7591d637eeedae7e4921f2ffabb22127426ac8c36847f7960fa35f1cc29f7fe1db6134227d24a773e68739cf4b71798832d2f52f51979d668e53a417157968f8bc89f90278dd21bde90cd7dc5f4e179e62e67c3c52eceedb3607a64fa33430221b978cc38dc6d12d721a2b22c191b0889fbd12dcd4fe4b960473c3bfe3fc5bc424b1282501ebe407472c76cc3e2880b4af25bf27f2c286953f1e4b7c4060b53ae1ce794c7fc46f948d3774a68a97b1bb14e8566f6fc5d572b793eb623ff9b725898b1783e71ce3425736646654ddced67d796635c6cd606c1a8f5", + "27e3866f8e8e6d235bb498e69476f2c3ffb4a70419f180f48d9fec4f6c4d5f5a0e2090890372f9af15fa1891efe9dd4bc42341dd71207486c5c66849a2e18160be0ac2da883434104717ca83003e629d76d42142cfa395d065caf600a9f76fa4fda319c5212e7ec3be87170368c04a00f696cb0eeaec9fdf5bc9e5a47ee01a6b688ace31335938d5701d030faf4d870e4f5cd2fcd19949842a2e1073158e87251b7d9e8308ec3072cbf14d2be323e589bedebe388b11d769cc279dc2e8c36120cb45ce00da412557df3dd81a52fe9c03c1ad7a2313d178bfc1343f4025396898a2759e031c206f01ddb16735db11946e7614a3681b4eb62ee000eb2cd9946ac8", + "1bedf92c8a97c73c4214b5aa4030d204d493687dae0a92633b5accdcb1e930558e333cb083a821f78fb863fbc4fb089afaab9c0204a7fef6866d8f352d22bc522e88bb9cfaec71c1a9242d45bbe5b6f94a51e30a729397b6088a4b448d1ea9d3e2a35d9df27943d143b7ff95268e1a95634418e196c5c229b16ea697f7b062a8858a13728e14a522c3284328bab6d301e50ef7e68864762c2e19b45410efcd4fd9d763b9e4029124b7de2d2fd344d5d717092d1c0d1aa811b3d325f9e84787046fb25cdf697d62b4264f43ee78552545e82ee21f24642b8b15289c69dd37e7b2d230cf2264d47898da54ad8bc5934bbbb9d72e8d56ab5ebec6c1154af96e3069", + "2253cd8c74fc85c35ce1d957a9fbf2b1b814a961a0aab482d73965947266c6a1c8fd450be2c25877999a00f5d86d71b95d6a3f32cc1adddf58893fccff12898c66631f5a9b685a91f1970846f0066196cf45dfa32004c03f2d2a9a479f1d6445183489ac14c9328fb5520ca3db9125bbe1da51761d7456c58b88249b44ae99c3e09aca504c987d941e7960f04f36291bcdf2aae0072fe376424b66ceacba3cb8005572333826eb9481240fa71e35555704e042d11c82537ccc8ef3f2aca78d308b7ac22152acb671727b526cd3c6ac8d4019c0f003d21833629d065441c790c10cf8d77bb07c7942b73f833612a6197a3d11e7ac39c3fc98e7466a6b3b482878", + "18507ae76404b415bd9682859650f5f23efb4a2f17155811b05dae96a174058b6af46dc7c42798ec2d668a35b2721fab1ca85ef89886932f5d6e11c5674c31348fa0aca586fd54061f60ad9e5f90dbfc3585082ec5d56ae7c335074a4634caa14cb0c675b567e57d9e048ba8a3f6f559da677bef99bd9bd397ad64ef59cea4b6999080776202faa9a4785eb83e7745c32d8ff895d42a1131ecdebc166c398aa3efe946737df56f43339ebafb0d85cbf413d042c7db4b70aa4a0c050bbbe624a2be4ab8142225786adf3426bd1a5cf276d67725288e7f2016e32ef8ad741ff314e89529d66a2dce200babea801d9e30af743c264c8209ddd47d4f5454a0388aa5", + "84149727b4a3e9c43073847d02d711eb4ac2bda2f1d5b062a62cdcd814fab6cda49a4ee816297c8f18e4eff52533c5ececad5bf6c49250e240d2806b3d91f9fa01cf92aa3b5c1d2e275aeab4a48a348a900d30d553cde046cec16610fe754690cb6a15a20233b8f81d4515aacdb9b1f6e7a2d6ca9cf7d427febe2ebae7c5b9be3abf8215dee45b88c9c74ec354a80a39e35e914ee686ddccf3265bff71f1bc10b46e659b2d604dd1849a7dd832d01b66be4e5378027b30939d8e143728a6a9aef98c19908a4db2c6284889516130d7e36198c7d40ea618767fb3c90bd5586801f032906402dd2db28272aa8aee600def166aecb33f21c077d6c2087617c5d88", + "3145e469053f3c38f4cf5a07d577dd66b6bb344e0f33d3711598c5551a6e345db11b7a144c9e60ac37357019cd81f7deddeb3bef519fdbcc6538b61611d8d8a479997418e9d03ebbfe9f5a8338631adfead0c1629d7d747ac4addaaa527708e739f71cabb64b40bc6911f25dff87685c48d3a4f779e3f7ccf1e18ff15d222ab381ad96bc25feb414d5eb862ce7d1cb60cafb7135bf57df0dc25df8600e1943f2fe1c209d41d5c4b9072724ed154656884ddb589fb240e880b3749616c8ce10c1fdba4bdc403dd865736e4ec17eec19d56e085e1ad8c9262b802feb7a679e6c1ae5da6654c69c70a063dcf241297123227c0b3e78585f433c0d316aedd4f75e94", + "25b5421af5efc1851bc9b5a1e6f46cebd36d9ff1657f13a82a458580ba3523f42bfa299a2205b2109a8d2998a8dd8111a27314683b715261287a4a00c1397bba3c4d79aa3252fc5cffd6e26bc90305d1f5315b49c72d201b1ca696efa0e9dd36169617a38608db095a13faa61f5f2017149d08de54d4d652c96a307a4875a4f37f455b0166334f2ae7a22d3ca15edfcfee6a2289bc00fa1c567d35a0b8e333ab5d8ffe26a52eb10cc18b9c2fab0245eeb7bf198c5b5bd101da9545815f0c31f7b7c73882d3cafbaf8067cc8dd6475b9f40114086156c584ed79addbb4c8018db29e98a8cf19d187ef19fe78c545d30a5fc1aa6da8bc5cc101e1576c6cb855086", + "ecc4296499fa2a70392ce548124328eaff43a11af95de11760378f2e5233e4691a4c3fe2db4f17d875c5a6fdffe2534d388a482b5aff97a0f9250d2fad6cefa2dce2b6b8c7e6ece476226db19b4017b02030bcb3040ac1f8a9010958a511aa63218bb6d1cdcb89b4b0e124bad3e00bb3649c34f1fe8eeb352103a0b45b4e1736ca4dc3862bc716e01929afe6cf42118c6558fce277b91b0c084fd01ee5edb067854afd0b0ff0aced9a1cd1185842eb3ed8607d58b2ab2efb5fafb8e01cac03383ba0319bf9fcd80438a7b280ef4ae96da3f613a47bfa14796fa7be3ebdc94a3e9cd0954fc3f1115c82319bb97be42dc7c2be369b8ec4cac7e5f8a8007a48bbe", + "2ef8e464e56f85c0c836880f87a54b606e9d85c4cd3ad036e39bc1152ef0b9953705c2faabc91272a6f1960d15f3fa972481ede46d682fb827987abae3cbda39fa4e483a1eebeee3bf60f3de1de62017a44325b7ad178afd9f0fdf353811a7af27b8abac8a6ec42cb584c0e4e43bb2375fa057fe12fe9d6aa7485bd02e760896234a70f162f4f271f676ba991923e3062f23cc81fef797ccee9091e771d1604ccbad395121e351d4911062fda967e6740a8f950c73c6ff6daa55e5393e104049fd4f7ae08f0964423a6a6ada942f8fe3f72635f7fce8f8526e996989ac1a7e1a2d0b1db39ca0b79c183148d7fc4c0840f8b5f10cd31ff9db1046cbf65110145c", + "ff82b6203f175df1105eaed389cbe9b7ad944a6a91d7da540fdce58695e7fd6993d8e8e04b40afc2826ddc3d8b84e12ff3e49cdb71decaa05bc8b826f9e9b21d12f77ff8e7ee9b4776ff542269052efac183698f06e994cf8fde4937732d3c86ef5ccf5e886496c448955157a86cf922e64c7440200b025fad3e5851128d4bc3892421c80b68fc8ce0ebb15776f8db6d217e8d3868496e22085deb802fd24972a2f616534a4b538bdea112afc3db51169a9889c3002c6d14e9ee1344c586e16d685847dd1342bf57b21ef1d71be12436da6c90592f39c71fb695a1b7fff8e10e08ed9fe4d1c2703d1fde0b2f194c3b0e2bf1ae69005909c3ec69d2d415fa4af", + "bd8710e315f11f157e3fa3068e7b2b98a05d3f323b0b935b14137fc97bb22aef955bd199c5c7b241629aadc84951b1b9159856f7f98d7fa34543da6427f9317663eecafac8f6d90d85dd58d9eac0bae4d9bcfd019a9c632f8e93d559f00c2097e27121d99009ca964315666337fb9407cabca840df7eaf474c10c4fb4b00f199c23148fad1b74df249f2f819c538327c5b749f975858d54d384f29cbf333d16d33c44c48fe47ee528b3a255da8333592d7b4bb4241b0cca015414166a34cc8e24a4e83913a4af41aa5e26450f82422246376c36c38966e21ead659fc94105ea9755f89288bb55ccd428c56229bcd5ab817b0193f33527c2bbcf3e385959358a", + "207e864d2b5b919208faa75cbc94763055a0244767dd16e9a9da636638298b914e662d2389d0278951522b20ad8699e111e5eeaa107fecb1c29ef964b17e3d270bdbf71365f80be2c62e0e29bd8ac70706c4080fdf581a3fac006ed7aaeca057fcbfc2c71f3de6485035e1a363bfd2cfa5d5c71ae561ac21ce30802f2fdb915382f161866a82778394dd11ee27c020f83fb8ace32b8be8ae7577f4ee80cfb97657f513ba112eed5c2663660adf04a3f9e69f304ff6b8dc8d63d31703c9e99f1034e75acc89eaf76a29c6b1591995b4df4c1056459f56167fd7c93c786e2f89187838ec68adfe5adc18fb5cc7900e7651c92b7b92837c255c97522c02db048c45", + "1e75687a82dee952f9abe9b065968df6f57d9733b91c609637065f824e0d0e4df53c8ce7a612cc3aa66f88482ef58ad654543c72114e7445fe251b8202c8a21195f1d475417a64a661969120e4b0a9fc0e5832db30bb5e135da37f25c1cdc2a47e8b1445921f44cb46103562235f4469b5e1c8c4383d962550d8315ecae3a78e911923ea835c7868afd6cda31b9a95694cbeb4c257e9255500fa73a640fde2e5d8e02f1de5a57d2679a55a1d1a10c9d07176d33dc12dae21558370f4db004b855e7933da380a4fc8f096023c3b5fa605b2273951a346d901860bca06613c595fa97d179af9ea73f8397ea43f3f399650ea557d6bcf607bafc9eeb17e8aacca37", + "2a2b89717afe0e811c0e1878424963a8695f3769fb81d178257903a2fcc517c8ece1b5b0ca255ab3e5a03ef4217d171daaae5a05d3bf022a3c5877a49d7555c1ff5c36c3df5498a46618dc0aec6e53bba3d29963c7d4346ec18cf24e358a7ba046ebdd8e1b6136b1daeac826eb9a3f5a1565c5314efced9241cf3d8c53cd322da17ad7ba8afbf1d44ea1a36675ba81762252e90d677993bad54ae0434b00bc534b98f7112135fdb21577215b0130517b378b668ca064069cc63fdd3bbd8b7870af6adef01ca7dbd7f8e9c20fcb83a33127f3c9b5b3060220585d76db745472c3766092163b000903292f06bd6d1d17269ef398cd95c1f09a623a26d57bc4198b", + "240653255235609407048e94b375fe0e001d707b7d1ef3cb21704b91edb0ae097b9dde083346f05663b455a2aca2d914643b6fff31afca78d2a14b981604a8111c543e3bc71af3ff9ad08a0871bf395b46d1fc99c28891f115c24f3f79f19c7fbfe6c531d49b11e3e48eb5cfa154b828ac495acd5cabdf2dedb154cfffd5a48ebb3afa67f7bd99f6250ba603aa0c57db8dd36cef70cbb97f54dbd7063876d3f4fa393218ba7d998376de7942acf0ce77500c0c06401b7daf776d3b09b3fca91b0e6b3bfffae9faa4d0dbe0e3c243038e6271e5b76a8ee3c1e784dbe73a0dad499217347616eff787c1f8860d4c75f16bbd2e007982afd52f3637c947a41fa05f", + "12a06bbbaf93f3a6a3d09df65ead7ee739a6b3b56c67e419f877a74236febbebc93a1ab3d8d27ab859ddd48da9f7dc5956e891a98309b5f4109f47ae351697b6cb0d9aec3c81ad41f2ff6f6d839ab6cd74d6b3b26d16a8b8754541bbd2374f386824189276d2a7086444c0c422192c6ee308e4da0aa6a136f452b6f367be82aa830b589140dabd59b70bb4b008d01d475ec1ec9dc42515c7a2263c18cefaeeb65510473fc6340c9b6d963ca28617f16cbb4489157d5ff581da8cfbd0ba00ebe578bde5ab501a5905d8f4d8ff5f111c982b56a38d38de7b4c27df7b9f8e7b1760fe2419398c9e55f2696758feb2d6f460518f070fe3508655c4d478e202014e4e", + "244cc1c944af8f886e2bb0c7cf6e2934aec144d3d27a7ec44149a70a44483a3ef7df64a737416dd8a2db469eee023eff85a1bdac8cbe011ee30a3331f9b6c811af612551b40225858abaeda1f8233e982c27ac4238e995f0cd44244339c742367310f645e54616bbc4277b2c4e712fc92cc780f0da098443e7831c76805bcc8b6fe77333c86f03424034d39ca26f0d60d278be2475af4a9a9142faeeaae5212495ee0a9b98526a2036a0fffcd397556caa7ce55313494328939078944bd356bc4a0b0b8761eaa4f9fbb90ddb38bb668d679c2abfff96a4eba5e81aa73fd576b07f23d2252c1f1e2704fb171b27323e478ce759313802577cfabd04fa36541a37", + "16a319203374e5495937c4e8bd1c6db659ef76cddbee2a24d4f518e54447413724cd0bb7584de828bc854e3e722dab7f795650b0de4b057d102659045578ca2f8e52a69124c808a233602e23da2e523082a40486046c176e34ba8eb318c15aae27241bfea34642c0530de3a425249b651f9c85453027a3db5e1bdc174a8eae597574238b1e17a18ecab2458b54eb03524de5e48a0c1a9de67ee0e493a39cd84fe7a4396beb3443c3cfff22406761741e70dca28c7a9d03bef8e7eb82611a6d1e423474375336015c4052baad4f885ff4dc91f4612141c1cadd946e2525e9e49c6dcd9bc03f94327cb3b6fa9b7acf45bde40616ead40091c0d976366113b141ce", + "2aeac9eae2c7fac0e12751d0a46b8ff45ce529bd42c6c38504e10baf5f8c8f02c5ee031019b0c7bc8d70b51ae57b4b8bbc5bbd630a252ee019404b87651ebd915609ba24b3f7cd94d5d3d55f7fe175973f59921177f8f6ed8a2073f63529736c1690907218d9ca8e123eaad40224c2a74cd8b4153da945ad8fb1ad03ed1cd7ef5ecaa7115655376d934aabfdcedcc14e0ae09177cc28f62fbbacf3bdbb9905fb8192cb51665847ce222c487d9e29badcedbf5c8f3dace408fb00cef033a0436bb648db2f48baa56eb4f8fa153e8c49a5d63d8186d2ac1e91dbed95bfc40de88a0a4c148b4c23e0e0ee8b651054ab89d5703e6b097117a1381d5ef453219f4704", + "17a1ffa0dc6ef6be0ae545bc7df40b00790fbf55429e5762d6afbd510b8972f079469649c2998890d2dd09483f9c1c0c14025b2fae0ed30eb4b3c8c5acd41142ce4266661fd1d25f2895f1400848f3d845d9d7cc4f032e838eeab23b9d9cde03c8b89131fd19a2f8a4553720fb28e9521e39878be31af6afbb74607cdf855be316dd252b453fafe1720d74cbb7f97d7b72d7b6dd4979d2c4055d7dcdb1d39748f06fc4f40490ad8e134e02cb68ad0df2f5ac38fe513b8333b3ace221fbf845c43272397a3ee1734cefc9143036213d56101eedfc66f5754759d5cae937be962947bbc6bfea5f05aa370616eb4dec0ed1ee1d0adf6ef32acc593a5a36209b6ac3", + "f0c22ae2b9b4833a3073e5dd8f3a29b0c006cf89095155731fbf3c2c877209d67cf83729552e8c0c9a1fcd4cf30e75946dffff28d7f2af7fb93762b688ffae3a608ed37e9c0d2a48fafa4e39fafa2755b879076bbf704cd315616e0902eb650f16e84f1662f977d0bc5068bda7793ed8fbf50c5f4c99cc342a5fd7c7bc552240a5dd82d2dde9ad0a2c56a53557f87e4acd27eadb531eaca0a1ac9d7d54f7312f2bb3fb83329733932003f64d88ac90476594405e3bfca583bc7ffbedb23fb0c1e9e896e8794fc61592667f2ab22c658f72bdf60a0f6c7519b383bcf657e61b10931c3a29935dab84d285b829221c80f5ac9737d022ef7a127191f189f8f00b3", + "8afcbfcd479d67a84d69e8e15d66245ba69f7d483dfc2b8d822934d16f1e630fc4bff4cc6892c8afa77c96fe786f8ec9dd485fc7b0a8ce550980e7e4086d98a6c00023ba883313a3082e86d007cb75a254fdf9ffe881b3bbc88ab42cdfc4afbe51018ae314896994196762b8bc7acc84482033bec2ccb49382d9f2b767afe84d8c82af7a12108d116b33e2276b356d60962b56aa5d2701ea0564e1753b1df21801f08cd5b24763c2de1ee30b78078c17f4c9e9aaa9d19a70fdfeafa5f72926497b0f97117461269bda848199d1922f1736a0706cff982e85ec8bd6b9dcb6eeea70181e32fd965bb43316a6a3382d7f6962cbda55381137359b78cef537084a", + "c5bcea5b2e6d6663d3d0cbb22ef4fb683917f4897b82229570c5f393189d8999fa9c7b3f661c0cc29107a1e6f04bf37b13402a83bfe843509df46e3d069c2558ab6bb96a729853fb47cff758fda10851a65d67430c58b54f92b369764539d6ce4da5f40645e2dd42a71d0bc61451e1b19878e0a3d46cd46934296fb5e73e2328aef579835990a4300ed74023fea83fd6c63dda1fba3c693b10031fd1394cae21b2474c36e8568109f8505d0a25a32be20f06c573eb0587090330b6889a722cad7f7b2368f004039dfcac9a67e0907c9423a9003a5a308ce6d1724473eb73ad915bf8454914d80a92aabb3b4a6379826898848c4f953f0ff921618d53904dc2d", + "1dcaa7620c3b6b41cf6bc5f68ce61a939112f03eceaa12cd0d7f35ca95951708222c85fd707cd84e5d0e1889d55d427d42cf767d8f2398f7a2d7e67fa7fc706b5e3147e90b8c10fe0ee4cedc53cd66c5b5ea762440f0945b62eda81b7a43fcbd0da5961ba62754404521cced1efb1f93647a0f9acf53d3ff594dd320a693bc6910ea98dcfd9371be641068c54d648daa43b703ec096845f4fa90f373ccc404a5b948b60af044f9286345d9eaa013c025f52c09ca8472306c331dbc08c30684f23d796b8124d36743ab47876d15bf99a6eb441cc807a4cc5f5afe61dccd91b5d6f438ade4d29f1936aed109982d7ddcd954aa2b03290421afbc865bcc6ae1ce4", + "ff56c586c321eaea74b9531f49dca801b3a8bb673bc1a01fd5acb594cecbe48f4f96248b48feca89ae8b8d748778f333b9d7c97a2d3182d06c1c7af77839043fba784703391c4d51cd7af513c4f10275b8d5e2ff536a7a84841b65764ddc5d190b4b9922890429de173cf98263f6375fd352f0a0c18f8647638afa58cf067e84b4e1ff487a3584de307a49810e999bfb3a0c3e270acfe00f8b12f5c7ddc7c7500c9e6c3772353b3033b4a4ea08822f8888d321c703caf661351d4bc7d7182dfcc09c78dc0e0427ab604f6377f7f275041d012555eb6e388ef39c79dc6735ed32740462ce1a37f9df332442600f09dbbd3d7f29a7e694dd457da9bd6ae3b34cf", + "ebbf717af4f8a60b8cdc38c349231c6fc82cf9e4959f0a9031cf63a500a1d9b8a09948db11d810f68cdaa2091919c673df3370dc9f40c2c78c60be51777ab98f46a9406d804f69b729d51b45129b7ab03896886680ed34b7562c6af198dccaf1467356922c457ed4970509f42d82fa828b47dd127f5f3f5958efdb8a6fe54166e87e5e702395268f8f75ffa109bd9bc059a549e556e7069fb0837c50759e35afadef8ce574c105722d5752101782d3a06960324a89270217a5e8db8f99791624cbd302b195444e5f4db3b2cb5cb35b81cbcc88cee9eb9939e3362e67fa9ed59164779a8ebaa0eff230425efcfcfa40e90a1a3274aa8cfa7af561db4760cb348", + "1c87eb1159618a0023935aed0af77b7f694bc6012d7da64e831daa41eeb23dc0c92520ddecfeb6e2feebfd37fb8d8873c2bbdc1a1c2ba33127cedeb3f8a3301b2cc158fc4038e2512b5f41560928b629e54de34d4aaaf325d2b9967617e860fab22fae5c3eaaabb805df94d372b3fb6605e1b13caa976edea3a0f1adc997006b9954a3a3934e71c7de282546eafa7c1799500f1d8a7420e2dc81160080158604550ff03fd99630ec098433767935cea0fda7f58581d932a718701ee7db3aa4cbecfc93d91b1ce14e8d201deb2c82794534d39bb4729c55c32d23fa4795f25189bcb66f3abfde174e1bf34b66d8ce33a2c230f4470df5267b14c35512451b1699", + "2b5ba53bdf3ea9a6917a27d7fe4efef665af0a55f6b2b8762fb68d00cbf1b86df00907fcab406142a5472c64265b77e92e04a7efecd035dcf68acdae1c4386d69ec8d2f55e5d6abfad9b47033c2d813eb58c83527034140f67a34bdcec077f1726a40f35e3647fd0d7a582ba09c7fde71a803bd699e0c4f437988d4d38e12d51888d746c3fda076f27ae87586006434c1e79d1af7ae796280047958cefa9e090331641f55c734c7b5ede7b5c0d297c943e52dd2f618fa6073deac1a1ebfb064094942b5b0a77e98b69cb105c00cd17635853033d574735cc47b7454591e999195462b7d51f88155ad96cf722785fd024319ae4f54d23241cf7c5dbc9b8aa3bba", + "1e97bc65c9b42310e3fefd487b9dafac19dd649ada08954aa17a858195d1203b128adb37632719f3c916e70c00f886dce07726f43a0f6311c0a93850c97cf48b38101f6799a719ef4e299b634766870828037f8b01ee6197a9e8941a3f27951e8ba082391d8058d94f5c3cfacc8bb0f46f4f5e6cc748439d2a759c206e9396c8e91ea6a73544d37a5da86e8d143f21dd5577e49165b26b8a5609234315edaf9bd808bed1a87df8a5e36e9678d6fd5dedb79f5721c21de5737d9a131c49df5da2a15dc77b9c88162f4c0d47a20f2908983d065790c7247d09a356f208e91a7987ea94e0f2e7b6e08c39eb1d1ab4aacde5b554afcce48122d07bc105d78af770b9", + "1c86838f900f4c2684c8c6c38223c4ef5bc5637712653e3020983c9e2075e13a57b292c804eec84c6248c1802a078ff1e3c900fa0dc86e8bb46955286b5e9463922f81192fa7ac7044c6c3068ef55d815101e30ae3db1e71474a5dcfa0f8101e7bdac7d3a8c10ba086f21e4fe0979b03cbbcf906611f937c93b71d1de7bb915078637779cbf80dcf6cca7f0fc18e40b0175e2015fb7e1af77f7d71f0871a2153fbf81a746a58ac62d363bde4efa5c0785d1716fc439d2d57ca5b38d7fee544f82c253e67a1cf604f707b705df5ace49ef9ab525ef054d3b2633422a4382752e4b7c944876fd8326169f2fd58662386217f46d8d7965d448e51f75a1edf4b0907", + "1f2d91eb6020f5a2e1c185eb58529b70370fc0e8f434f44d04933ddb1e3cc8da0ac682eac03c81ac28c610b6221485e21ae8471219ee1130c2e0499f9abf0b05efc7c2530e94d2757cf0504f4689b376c57a7e9bb6f1f7474fbd4fa95ead3196c6c0ad7ef4e908bd618180e839d24caf12a47f035efda878613b43a3dd5105e2a8f0b57602a4737bf2979a2117db793824cecdaeaafb3814d80b44c4a240716190b1b13c203ee66b8e4ddafb7770d49a03b66ed9e2e145c4dca27fced19576b895980a4beaca14aca1bf78b09d96fefe81366c260329ad9ff9bf6c7b667db4885c0f62158a036b46a408282a1263a611983f2419ad1186877238410b5ea11421", + "76ca7c33edca9fd55551cc46de56270193e22abc886c20b0c1b3d2099ce118e52b17b6a57face17aef5b688975cefeac5e5dfcc76edce79e20cb62edcd5c0eb8d766d5240ec47ded0f79716ac2444dfc1f54ab30bcdbdf14dc53d19ccc1bc534f998b7f426ee7f8f454d4a11c1edbce2d24d714ee9f9993689fbaadfd579c9915da2a6d6ef56e61eb4166e676039d61df2a21d7421166e91ac19969d247b0d39c31355ba4a1dc4ed44d0865d0bd7dc8738361404a52111f0f2cdb453567895b443999f99d39b7bedf6c0928ac7dc21848dd54010ffe6c331c87d8ab25f771cebac9d9459da126a106f3fc9719cabf1ca8153b55d7e1770fad22b4b02ac32783", + "4c2baf3ec7bede479c401bd4db14e28a5faf32801acef571b9164cede48f33a85932d59091c8d40a138a69e4524bb583df764ecc57f62e26274365847f219d45b64cc125015771905ad416db81a35d7ed719247d865636ef8e2b2f4751efccf57b679b3964ad48a46436a2732b40dedcdf6b7dc1ebe5cad35e85fb85b703eaf036c76b074ea20576d9584013b58a49c81d60b29216b860f08539e702ff0700509e5063c649602213e8ea14b103689bfbde6a0ad7045cd2d524de7eaa67bb46884695c496a96ae1a5b4883015f2ebae25e10f3089b19224b6d748364edbd71c82f647f1ae50762ef4ce4ef081c8ee41e1569d3fad8198b78869b33fc5085bb23", + "17c36852c11439eb4ae9ad073e3314631567f18d681cb9f729d7dbb249da77ef6eebf34e421fb7d0de6d4d6b29741879280b291bd973de3c96e2059d9c7beb8094a308bfe143687884e44c5501254bdedb9f404d165fc21d6979cef1935092d9d2ba0fe6f894542fe49f6ee407b260bb08de13864300f6ec848882bd197729397c33a9703ff5191ee12119ba8b00e7a9f58c2d68c4741bf0f9f50660408ad562faf06d9d985e99116e9dd54905e035757a8cd9ba9bd5ab6d222ca116dc90500ab48b2acfd9034d85346ed08b5e67f0dc26760d1ea3b9b937afa5c26c03680c68d9a65b3afbe19fddeb0adfe50dc84d33cd771dd90496771223b15545eb8056ac", + "2dd1ce888db7fff89c9976ccde17b84c61e3cc711a68234f0458c26c189822f1d458840338b6ed36bafc3a00a01e69ea37387baa9a19f6d0876a3428b6a4d683569c28724b8f17e8edb1ab354014a9f3b2f4268b8b5aa6e6b3b6da35f32eb4f9ad76862f1a3bc4ee1954efff3d35c3dce4f9d6cb8ca977aa21fe7fc98f94b406ad267341228c572132cdcc431b4f90a2fb7fa31a6e4bf35dbac3bf0bc13eaa80509aeda7853e1c2b0d59d7cec4976c1814c44c0b214d5e2ac49f3528b3f085cf3aceb3a563b2d0ef64608eba1379d77856e8feede16b9116d90031ba2b684c80f5ae09790c3cd14c1d89eb6d6fdb687b4204a54a0991340d2320084b55ff8ce3", + "5d5936576e332dee73682b0dc0ded67d4a6a7df7c4617761b7cc00ae0b1cea5728a7d00ba837f6676b979e6351d44cddf07e36d677f7bc25a27dd4bcc6ff1e38df0e8d1f70613c243ce72ccd4006b57a709b66f84be6059223b7d5472024dcafa0ded3cab46c313d2302aa8369641f1aacff941437fc5f859645065e472c3d3c9a340e7450d8058798b50b5138ca7d20a06a56c61dcd02afcce856bf18a1513067bbd2d2c368c3784bed81fca0cc69764fbf52fbd436f92eda399bbc451ce1b8ab8c60387c249058c37e429f89d91b8fa7329901e02f6607c15259a0f1a51531f451338d5719c6a42893986d6314f7ef7b61b0a9bb492eea59598798a7a2b6e", + "173062506020be8f4be6474511e011cd647dbd09854e2e019f24add9188d8b4884745266af6366ee731e33b0a6af6346c8d87a48d65a80e8a523cbc35d870089a7fcd4b05933789647fead41c5e79575f0a781baf254532b24ff823f07ec3bc7648f3f5be8aa17851c27f267902303546bac438a1a765f23a1d7fac72c0fe015a249048047d4c950fb81ec51c99539bf02c67698b050198ab45809d79644aade827c3071f1c58b9e7bde0074cb43e9e09b54bad0a1f7762dd81ae65f1e8a2650538f26e629642dc73aedd180b88e0f8a4fb0da9a20848a5ab62bbed5ecc779db560d3295a4d133a8161ec4f4c0f1003ff0bb5d819e157f01fda70caa05a9766d", + "10199e0698eba7d2c98704b3d285e14a6e33ea5e93f16757276f508986ea379b878ae8879c359f8fa12e9221baf90cb92f0cb7cb27c127722f58ab4066ff0c09c150f422e03f13c0e5227269e0665bc25e0291a29652f775c034f40ae3f8c6cd8a2c1460fa6fa81f9c4fcba84ec0e605f0fc5d75a021418a63ea9525fcf350ae0172d4c3862f3a7b7ab48329b0c7a346b08ab591e728604b63632771327040bc71e988f98398fb016cbc737679ac9569ef4112a06a625e3ab96a3cac6beda10e76c9a6033b69e984ee0be1fe562ca8f1a11614d28086fa71d744ca723151e0f18e58c23691b4b79fe60ad9f570ef67c594fe51619b242a018446de9cb1ddb417", + "2488132d171641d6becf842f05dc0d0b35cbb2e666c7819dedd9f396de749d21ca579bf437c5229d7767d8df7128610ac1dfa41392474b489eed084350e3b992e4e499b93d2e1e71bda0e336558f9c365af2fb1b053c8cd5ad80c538959d4fafd3a4d4b67936fab453185857eadafefd6b846dd31f7905c8123d7eea2c9df626e73c4a768eae9f0112c9ef0949b462ba35e40dade327a168dc568b5595ae15e63d15d592b0008aeee60a78fff11b5511c39a08a7fa7c3ac48256452b62eca7fd532fc15e97bce2265aac3f6d55e1a56409f6469088324b1cbb28b2a998f13f335fe69293718d2034fe9a21f42f53b7821f5f07d1767f453beea158446777bba5", + "363e047e92b9b323ba3b5fe9b48266db9f2800d40df6b828fa8115d7ab8f6885265f41736dec468a95ffaa1b05ef7da41a3ce92ccf5954a3862392b4bbd6c12fa8d13eb05e7211df97e3ff22d5cb17975db94a8b0986a1c76e45a67bf09c8b6d4871588701b4065944ea53e076ada51e266bb9ecd66a23412fb4fe8952c8bfd048cb1a6866ba9365aeb24b8179c08a82dd169071d4705dfbc08cdcb96ea709827636dd2d0e262e419f1cb2ede2e001715584e0813d548d7f3140e8f1f78fb5772123f676e8ce49576853e43b7ba499485fe0fc4b5cedaa7eb2ed1701af16ab606f595fba90ef7a089cb5cb929dc1ddc3940973cc7a3ae28b3be017ba42b4ea59", + "53287ca72b60f7faf0743f929d863fdef06bae5c4095670b92398f69c18c8f0457442a871c0ead210e719557412309c1e2127de322a04d3a8e62dadd4bf36d725eeda184e475a5aa9d07087873e0d9f917c06dd19ce98823711507eb1709eb55490f7ab5150df0a78ca2c29d26b14382c0b02a1bc1de66ce924e25ce13b110cc939a033158e333988421533a82ff73f5c5ffc5acf9dd169802b4abbdc56d948d201902cfb52a2a2dc492b996c63a93fd6ed7f21229c2a126b8b6c14f72b6d9fe697358d261ac2674f8e2d8de86d21c25396755c17b7f33576a49e49554c45a3e87d022eaff69a0838129fe652c43844f4d9fedc3bc4112c8a1ee199acd956e4", + "e644cf585c0d4f4d6b9db2809e10c29a77fd1fe9b262453ac52c3df1c993b70c2cd7c0993d8103aea4b137495b1adcfb8d8f2c54457f20935c00c352af1707036eeb400dba19225622357e0ac32cefa3a02a487c108c23a2b94d583a82730a37574afab7a6e534d848b5e987446d9255da8e489a5282eb07994aff2550b1393ae6a6e7bcdc3740e8d0d75f2e17c3442df89e641a54c1594437eb119a1552406e09353953ff7e7a955176e46940eb4c05fefa541acf82a0b5f4fba53efc0e761dba18a51e507a6e2db2517fb62d19e2f0d827f5852c862772ca19cb52507fef587c32f135695e49d3bd3e55dddb886ed1f74056e773133c72b86f3bf6d6aa1e1", + "338255d0ca95f33c63f9fbb606bad07972d80e55d6400a4780fd324c59c3fec36b76d49d7a17a5c0bae83e292693a59fc897098d3d63c9d3d5dacbf0f20c0ae32a66c6313acdff59aa576c11899f2a3bc28aaff696ba63a08ddb0fff04568d20e100b00061bbdb98d3652c296ae373c5e4cd50f515b4b3b67415871eed525bd504470cf9ca470fd53f461ad5a18a56044a038713a82e437b6c072ae46031306c6121aadfba7dfd063d06f321a53ed15d1ddcffa21b242e0c8dab055d85bc324f84fe18aac1d828feff87ad8975bba735f41540303d36d8d881188698af28db2f577e960d91a2f139064ee8ebfb2e5bad58f83c021f6725f42fea55dd8e29032b", + "4beecfc6df1ff09d1503a8f970ec2b76d85b5e44c75ba8867b31d8f325e9d04f4f0b8e29196c55e04194a0a550777dd0befcaa8f51f740e324c58c9e798aeafd973ffb1386af52db7a3bc8d9424db65f042b906f84194252944d88d740ea6a3753876004ebcbeb7e20cffd030f9a31f4f7babb73189838649fb63cf75026cc1c95821090645aa2d22680c9441f824e10e3edddc7d878ae0f4a34e97260404cf0bc6606eb0985bf0c194e88c63ac5a2220a072e2c8de3a262561840a8c96575da521ee379766f9749775603cbce687cc50f4b78ba6c8198a439e91418c0f251fc2070b57ef292d2e8cd64be9379ab1fe7d3cb0c051324bc3caf43c87e7ca9d63", + "33bfb627aa6552050e507f2b59ec3b44dc82d56caf1246dd5383b05c4a4e9ccdcbe11ee487fbdc9a2109e774681253c87d5f35e2f0784cff161baf72080b5e80c27eb60e6b6ac76701bda612a821bd6519f655a976e73cab7770ea4bdb657b7d2d11b010ac1611665669d80236c295468da283b8555a20a254dc9dee2fac69dd7ee829f9b49366bcc3d317aca0a971f6d1754da6e9800dda0996eed04eca07bc85e309e82cd0b48fbdf3b0a4cf30b71d7a5078671ce2f18834514f13b44883314bfed949e8586935f23bdf795ba47be3953e2368ef62f1b3283dad0bf23284ee29367c73b76bbbb73d9fef53e5e60ba6a8d6162de4d1af2837a4a6a7a214f2a7", + "14dbd6f656d960c6def00863749095b308e305a457a4f29458aca8ddea2ffc7ce4f44e01b02d723300a4f7c35afcd222003b254c49147f4b751367aa067e038c2be19fe867922241ee6410828b1be27c85ac7425d4c418d989e45b904cf4afe9623b7fbbf3cf5aae67e522dc55f189ba31734f7efa082367543be27e9b74ca9285ce54b91da8ea5f19fdf1cb594a2931b067d44b2182944e190adb0b3799670478dd565844e7d7c1658719f8f1c950280d817726e6bd5f3f2f14e06c3b4262220383a6e72e934fe6e847c792440d5c0872b3f2d9de834cf90cd3d1d59ec4060f8d0cd125cac6f3071171bbdf3d999aeca62e391066b2646e019848f1a380ca16", + "225bb3b84c04b5e3f74400256aea21781f3a0176a3472e18f96821874c7d66e7dcc16cb74190c85dfc7a16a776557f74105656863c309e87924ef2e185781525af9e113eb237a899271996da6f13af0657c49c7538cc9863cf8b454dcb81f7b72322323c7500fb13ee7aec21943b9c0cbf12c4447da8764ae1928d69a57280b85c3e62a2214622fb366ec7f3899fcf6e5cf5f8714f9653c8d384eccc3a6d4a4d8f40731c1a9065fac9e80ebf5e977e1c0f9b349f49119115f4bcf0671a30da485bbe66f5d8d5583248c6f2726401ea68f4e1db5603b296f67b1d4224d8f009889167b504706dbb1af4745f005e80475f20019ddc564be71dbcf78441ce131a95", + "783510c1864fea24c6fec9edb515269396a6532e6bbe25eb1929d16434b98ade21a5f1c9cab0c2a2e5c8eba477149e1080786d16de647b713a84280dabea423ba4a24b8e8f0769c6a57838c545fae966440a242f90ba05572a3194e41e8fecd522a1eb31c2316badb5067f1580d4f4a864ca05f3479db08c21d1ec3236185faeecc143842eb7697d7729b0f0bb148fe9de6f5d9f213392dfa1be4dab237c127309a03281ef88c021f2b38aeb3268f98e9dee4a055647429f2e32318b6824236afb4294624a50031db296f8a1b651871c66667cc6e05a1b2e9a03613153c5400671b73a025426e41065e54bd7f68a3534fedaaf9b5471f8c3dba4c5aa3741212", + "34ed4bfd07d3f55d58aedb608b6e3237680a258c46111cb57538fb55575061a1c9c9d20da591f9c2598af8673a84ddc89b129ffcb1d9e05f2aaf54df6e140b017ebea0aea9347b7a21ad9e81a14648eb0013e47d26852d27b9b151f8b5d21cdb8fe81d1eea6ebc7ebe899d55f631b514af7f73dabb96ec000ecf451fb96af183cd9674f0c6298fef2a14988dbaec247db8e6e313df34115e0edd312f75bbb1adb6a5cab68da0e6886dd2cc8ee6c4f4642b2fff2ac57307f8a4f396ff076bbef12c22b5a42ab6a0fdb44cf57e6760a5785d20ea8f30b6091c1f285616cb63fae8e9cd3e8cb04f6d2516edfa2e8b10237ccefedf9a4430b379cbe203bc4aef1fc4", + "33c1f613c783e68e53d36114aca6fe33128b4e6a0b60274628c59edc8f5e543c2a07464bbbfa3cc4347fc727876854a53d31156fc20b90a73c5e1bcaf79c118565fe60923fc108a60f24cbd10713b1f9f7b085f78153a61cc4d51bf366413c59ef811e9472f205c8c8a1f3af31828cf159b42257c8411dc4b0a320193ac0d7e50e734f7131f5c8b546f628610b1f9ccdabd73aaf20213a2c40f07f5201733a74969dc7372702b8b49a4957c5d874a953edb95544cda66b3f05dee0df7cc51ee9c0acc5eaa4ae7e107e5512c8ef00d6c5298291132684ba0488b70855d24226b6e99ed96d6a2ad2e64561c2a8c9643661dadf756b0d0fd0795145dbb254a95a7f", + "2e4257c3cef92b5eca2deb71df54e630bae87e33665eb6f36ee70e8e732c209befa97b76cbe66225e9cb2f39a6b5453758135218b25b5c0b10ed0c2970d720e3d6caa73829e9654a2c703bd2f1c360ca2176a40fd26bc0e8f3adbbd5b702875f6d5a96fd0eda326e077d381fc26ea964282864860be5b73e2e553d30f391b7b6eff497f701dc2fa8231d73b0c2bf09944a098225096f367a8d52b663ccd7d08ac8e4547de1ed703714bf148060886c6439fa5b3244786a2e61a8dd9a7d96cb7e5476c7d79ddab0c3780299c106407bdc0232addad67b8f4dfc9160de3ea1e589fcd03a20f314ab3f2b7232ba2856f2acbe83ca9cd05058116db0dfe0fe8d1946", + "35fc40ae464ca72b795625dbb866b027669dffd9b3adf409f841ad49ab9dfd05dc61ea25d9e25e8c72bbf4b4e037bfff73b22b8730fbcf2d6a0cca1770722bafb004a0e76b29e21705f58844e6bbfe41ead3fdc980b286611c45c4474664459a488f8e45e2ae9f6764705590c83bac68f1d56acb19f63a4641c34aad9a564a7b63ef0087ef1d030b68bfe8aa20f79c7b29950473421a2cbb98409602c053d2adccfb8e2302daa24d9b95406cb83513eaf5072fd7bac51c46684d7f8c2e5227fa13cc9b1f6c834c988c47c698d7dc7e67c86a8c9455618b85378f9ffddd35bbceb5ff3ede9e5ea0c7101aca8f4078348406dbc657fe8d5c1cd3148352c75d7b12", + "1740b9c53ce38063d25a730486a06662a7ded0a4bcc69934362c287fa4074d68f364e1f14bea650f74467057aef3711303859a6721e1eb8e518872de538d6ed84ee000ba174af32d09ad25a9d9deeead1b8d8870e7199f1eff710faf548f18163ee52d383fb332ce57e9bfe08441defba86e16d3555c917718ecc77ae83c7c7b29955c6aae768e3b87b46544cd212760acc15309d8959a5d7b4dc4e1aac0f57df0e788327419e8727e9ee4751df9550cd7efcdd2892de838dd115e0755871d3b45bbf9e32bf3e99446571ca713594b2e97a35e0bf12009445f3f1d025dcc7ef8d2ff95aa109f5046af294cc91b8c0433cbfa5dd2f842ef0f844e5077af66f996", + "152c2854cacc2c0972f70fd50bdb1cf76d03ec4465f822448382574ed3879cd2c8f1a90b6b7b0acd1be5eab9dd980b568a046d94346dc652df504a15b55475ba628a3697280548939c1da08eb61aea9a575cb12cbe698c61074c95393652adc032316b42e30c4345ae4b4ead710610837a7c3cea5521b0fb20a0027332107ed3db7ec5885a8604cb548c558d46472a59362087cf14ab1e2ef7634bde927b19d4efa351b44b92c170766278a569168fc1ac07babb39032e4ebc33dc985450fa5461f5140e3a20e306df6870b244238d46d6b204c9ef5be6bb1994f8f1b85fb56154ee1c3500c945fa9428b099cb5f358ec5e3b5231bc37c3094ca3b489d6e585c", + "2af55a1df765a142fb7fa729ecf55b2dee0895802ec6eb5ea56524aba856217330e9064c723cf582d7356eaaad9b328e3dd16ad3c9cb2d4c63b72b37217c8eec42f07fdbe342561aee237750e62107b3a4621e9746310b57e798ba55f49863b71fc81d991b901bfc574902bb2e68ef21eaaeafd276bb257cd8b8519ec407bcad92914392021401739a258ffd1a7bc14a5885a04e3b099bf89c08e9e0befc1fdd30d3708c99a2d68e2e3a7103d02d8b9bbcc965ee6f16b5794bb1482c8cae25a1ff77f82d3d20262854ce4a63fcb21471c53427e497d7c3bfc7be128d7c674bf69b9a690ceb6235c1bb4291f0c1d70be144fb1d6e0f3c834d7f988e69469370ce", + "8d84e0eb62e9c4435ce5f524e53e8eac8e90e33d9f5cdaf57082bc3b52e8f36ef1ebbf011c788db0f10850d0e1050fa962aa76e6400341e12be7e898dcd5ba0d95fee2913ca9882aec9f80b7a087ed94e5d118585d8a0952dc4f00be7dec0c95f7b850603fad78b456764f1881be91b35870a5234336b2a7abd03ab868399b711a8391989a555c53d2b06977f9cdea2ae867db8fa4f6ee5e6f4975e16eba51a10b9a5fcd5e10bf4ca4df89989dcda5d1282356272d37b589841a5beca13a6fbaa57bb2a52851cc869a47e7c715710ff2e5dd0985648ed033ccb93c8434105370340827c6b91fa5c46743d5d023757b8cdb41f6749dbcb0b9874a2ab34eff034", + "2e41222b92a606281fa5f58cc0b2d25ee39840db2408cecae044500051a2b520e77fe3aff317243609f5beb613fb46a326605d9a6fa784e861c4d696ebfb41ba0d12ef13129e0fa401c3b08c03e444c5d45190561195e2f5c6425fa94416785f3d29b2eb56bdf8a743e5b4e3166d3f6be9cceba46965c572639d9e093edfdfb6d3c54d3207a426a42115a5ebcf263fe23252fae16906510053d02d7dd6667c17656f14b0f3ffcca1093b8f996fbe68ab82cc08d58dadba6d9b7d58b8d9f0be24bc0aa98366b67a9d765cd9686d69fb4d31e39446a9b9a6959691d5c1cf98c666a3349a56fa0e87f2d17990065845d27070da308745b8d22e0c1636908678eec9", + "410c5f68f2d77e9d9eeeaf1fbe4feccde59d00d1d58fece90ef86355b0b81de87f4399a44e1570381a34cdc47d17a192855d0782e10d42be9b04391af4739cf48f8eec656bd5aacb5563803b308723f9f4c5c979433ded18c3b0b8549f6fd698180ec314b7d8f2d8042835c379d5af19fefbf49a0a649135e5b8e6105c2faf9daf0f76acc880f5c60bd0b242d0876698b69c96282abe95fccd9a7164f3bfbdbb57b030ef3b0e4dd6990e89dda05bf6e266896ce16873030229a012501cff2cecb03293455267c5c75f0e1db438137899b919f6971934409c593efcd3502a39fad08a69bddc0ae053e15d47017085fcf289b8b37fc8c5088d25c5b306ca52844", + "d4ccf7e120d2f1c88adc5a936eea785d12fb4ab480a62c24f58965c0f71b8bdf98e379731ac3bafbcbb5a255a3e41ccce41070b08320b8b9790b45f4633643ce368a9c2699a8b1e5a387768d915e0b87fcb729aee8996a89a15484ee1282dd0493d7045eac4f94ebf9e7ac861428589bbf41f8325c7048ea07de82ca65e8163c0aade2cc1b239bcdfc245ca495a96eae797abaa1ae572fcd8adbc506842a8ea8663c3308f36451634e389fa7c1391ce184bab8bebba4d0e12df42df95acc2c78df049489f616b000e15c6662dc9c7c988d77e4c86007cb2fc0fb08dddb378a621c35cd93b7561836a9bc4deffa0f93f786d4ed8c1795ed203cba9b9aff18806", + "2950fd06d7baf65a3a9560c8eea50914c00aba2390b729fc6683f631841adc625bc4b1e0d7d25a4f2a121abd20a4f89a227c4dff4ed527a5ddb9978b6d35625e049962a3d9ebd44a1038b268d08786243f4ede4e9a44caec5e7e798534b45e19773ebdd2960ea331439ebb6359c2e1151be9ad2673aea5ae9f0e93dc97db356e13e8942b7f4016bee1d8f8db6957fa22b67562c294f337b72ba0abec3de698e8efb59be94e93c7e010b0bf7adcd8ed560f45fa75f4531e1e62802d801d1e02af71abbf54b3fe6fcae69ed8889dd07f8f83dd0aae6de7995b8840e0b13b8e7544a612663a42dd65f716fb70090b954b8a6a62fe838d0ecb305ae26cddc3e125c2", + "116f7c224a3ad4a6f88c4236b34e5b53c067e224c584a112d457fa692a50be688d7c57af4bc1e2c8724d55688c4a039ac5f4e0c5317c8326e8c971f9edb8c884257f75b3f6478f191e76dc44d8d5a1e734de0ccacca20ca5ca715d1576dc8dbf263c5f9987c8d66a953befd535244e7ecaf6369878a2e6e4367f81731e3e8876a16269c0eefcc3f3c24a6aa42806519c11225141b873d5d00694add161a1875e47a9e16e1def6bd94ab71a0038a6cb265879ec6ed8e74dcf8a65a0d413fd9770d83859c0ca3d403d32655dba7e589f485a22a785e68390c00df21f18b37197464436eb9fca8d62c06ebcb62064dff621561cc8e44564c8dd89d21e383f788529", + "3073fbeba1da51dc2d10964138014731e35b61ef9735c6c17d50dc2014d0c39ec99f298adc8510eae861f91cb34bcd28f47ca7fff633404ecdbb609c8a630325a1ccfc35b63f9a942e5fb52db7f7a7a86cf4ebf032aa05c3b540fc21e93bfb9ca8810dd676bbce9be52c4eac9f8e4540de15bdfb002010d757f37891ffa46d7b2592b298eaf33ae166b5ab70e0e6585b89a9cc61ce803c16810fd5d8a15c0a8e07bfbd4e0dc4a283699c545296428fb1a1afc61cd70e10cf12aae27abc8390d1c918a251d6175530bef8e5691e5094b5434e87452d39bdd9516480d70dffeddff545843ea55771a03ad5bb9ed5bac366753ed413fc957e6115cd57c1ce9032e7", + "10434cf0f0c6076edae9f7ead7bc6e22bf12a3e85b5855cc0cb753837d3693d21600edad815492d70e692b88463ca1b1a54263d6c207125b996bb7af26d0555dc4b4a4bc87aa8ca52ee76c5f62892dc5f6576058dbc051d1d853ef7e723122e07505e2a8342452f7b3815da8b1015f60c40bfe8e1201824e76048c0e622550dbe04413e175229cedda583acb312ea0d3c50fdf226d0c5fe49ba2ad899aba61454cc5eed2f82ca59c2d63a810ca497b470896a5a74244fe93d50ddbb7fb60e6e9169bd2293657a788ca3823160b48162b5384167a9668489277c5bd4a3c3ecbccd699fa4568875caa9bea537f4ef3e21710a00c54bd5cb8f89d76a7f204439df0", + "9c162f42e6ee80b2faa9491d4d6045c465b4bc82779b09a2322ee5a3875f04cbc41d4688fb8eb9ef2218467b6b38dfc3adef0412ee69c4548cd79d8a43ce1b4386867ff9d06447da02601c754598defc95edef7d3b1767e8d3ffe0e1f74915394d2336072128b1f7c3bb95d8988725fc72fc6075181698a5577224f1a8df3b9aaace508e84015ccbc33733042c19ea2afd6a1cba9b1a9b8b3d697a04bf4708bb136e76647ec1b25972b0b58f93aa9279678d29cc07f5f0bbf33044981ba1903ac3b6f465909ef14dde82349fcb173b54162f1cac3c9aa7808366c30c132a81d03659df1dfca6100ea49e67e7183626eec126c2a71e501ca1733927720ef7931", + "1115aa73e2e926c49441d79003bca16ca3979027d4c9d0add9fd8334bb294db173a1d769b75de1f4021b9a481691e78a61d338563bcd5f97ba68ed19961169d0c7b42fdfbad21e5f7208f01fd613285c82889dd466257036bb90c02397f7cc2956394d8a0baa6d3f3d4eec9afd532abf9cbfa33021aaa8d2438ec53a264271fc6f7f1e168067d94a4da4054d0147863db0ff60a60998e107567408b46d90825cb1fcab00732fef34d95e004af03e0f227ee6234c5bfc68a31a048949bcae276effe01b62c60b2e1d8985f652255b19fb3ca38f1fed3cb3ce513ec5c537fdb364752de2fc56f49bf8a4b7a71769e049ee911770954f207dedba1253b1a9db3b93", + "bbead3d32131bbba9f45f81904e3c641ede584b1396b3ef93f404c8b257ee8ba295f9d04f33d1e86f47c6c341256abba2fa72e2829e70153272fd699a8e6b09cd427d01e714b3b46f3bdb30ff7e4e8c5ae9be8ff708aec358306f93623cedf9f9fc287fcfdebd4be3d3da56b2e35ddaf77dfe2800db23ef116da549f2bdf3af42b4dbf78912ff24afd47e463b83facc6f5da2dec1f11438549eed00aec52dd2e1aff7cd5a73e889cdec96dc304e9a650ad314c1d69ad3612873b511cd31a5da48bfb0c85fe06d346d1f80de5e39fa01fd9b03d4fcc91a44baa861d89b5907a4fad317ed053a8d1ab488a13020cc7329b8ce096b46df5986f2f944c672d986ea", + "135be0fa2b9e3244194b4476148f78787d75640758c41463f1b7a1e489de3f2e64dd7f64a8072d2ccfe1a177550d4cbe74851aa65e7105a50032cc901efc55a9045631fa2ed41265b2d98806737bf7623133b3fbab32d1d1ac8caf51ffb4f94f9524cc4bcb10b404d10190e13ea6a19cfa9ec8c32750bea93953914738c463ab570f96dc4c203b09503b42819e7755a6916f1c2ce0d0c3a9ee53e80107d9c1f745f9755f48bb0379696f1c45585946f6cea538ccde11438cdbe4fcbf66f29145d31d65a2a3418a2212250c783712e785cae1f10ff728f0d43a48bfea816531914ba8d8a4c5af9a73ed3a5ca7d9669eac4722cdf64d8678581cd09da4df5e5291", + "323b421fcbfdd03d722471f680bac435ded240fcf7e10d99b685f402d2bfac8607ed7e6d26c25552d1e7b21b3efd3b373f01d71e954916f080513b8310e5c1630347f2435e8df68a0b1a972d583e16c2b28c0ce406f07a0465c1d19f4025ab0ff858b6a1fc34866fed9f4fdec28cfeb8b83a7c5e8ee3adf89e1c28cd836484010c6348955d8120eda20bb08d8f5ca97f9080d557d089bc662a7453b2b091ca3cefb4f673696a04074066e4a8a3905b5cd721830db9841d17b109379dd5455348cd7a17c04a5a587423b72514ad71c7a9942f3fe2245725fe4f5f34555fc0c340c01caf5f1c8d6246ddb2c2e0c71c3d524e8fad2a39209805afa634663796491", + "21b160843430113c7bd9b0a355685dd203edbef80be23d6dcf28e7077c8d0cca975040961da319b00dac9320c225af3a1fbbcc73a84a600e07ed8f116e2f5f12e4fd896341d49127c0dc53b5413ec7afb758d0484efe8111025c2c52811ea5c89d69c3966925e962aa6cc0fc2d204833f2fa546b435d049e79fa78583e7141b7fc9752f31ba44ae800a2e435bfc1d71970edee98e3aed53d9443498ecdddd0d5131efb7b85ccd02eb52e1535b91d3e8523114f21ea62bedc46dd1c57a22821076be7370a82760abe18f6c58318a8e8c696012099900991ade3000901c19484f6e60c8b3e91be0ac5767183ee5b258773d99a4899c229f0f008fd550a3ec86bbc", + "2d216cf51c083493a1bc7dd3244ece6a1698fb621039b4d4d20e6dcd9869e8aad1811e104107f9884e6b7dad963adb6499ecbe2da450f069d39d4cf0af116aba23abc500f555838fcec9b02ce5c79ab7ccaefae51fb6f030d92c5376ae17d68f36b689b1366d9e4c618895b30d5f724d31ee3e3867ef493f598344040cc6088be05675f3c8a3ef6d0888761f5a84d4b7e76458f68db66639eb55d8d8e87ca02aa506219931899470e9aa1acb080393861d5706382128b68a5444d652bd5e8a95a7ee6603e0d2d213f491a7a14d0c21f6e6871701d1b4f5a887ed84ffca5f1db0ac28e42bf6a23f483e1da8c7806c2b2128cab997cc68025f57571d19aa4c60da", + "2193779eb6010f5e2d4d758be2dfbf9b4b26b6596b7bb6d39d6b22c428b161f60e2082e24d0b584a8c37df45f59be039b1a979d340f67653775aa1600947bc1da04b75129c448d669091ae81316d656198158cefc2082ea55903f9f81adc1c5fecd5d737f3bacb4c4a2f3c44642820974dd44daa8b594cf2ff55bd9595a0df1759f2d58dd9ed56600f4899b371920e8def6f511d29384e0b852d50774dbe8aca42a28e05c667e20bf1a2e5d4901819ba1e2f8c685b8125906f45f5a78ed4f5d60d21d5bd88e576dcb9c14580bbd2209374f094fc3ee85454fc6b21a27a2a4947e5804f89e23c1427162d8af36da0f73066e902146c750cfc0cdd3b4d00b58771", + "1be42db43fd51d08a1922e12e957f66d510d21b1d32f79b56bf19dcc9a0f7722ce302538a2e066c6ea72890eb58249c3064e7e27b3a1f80703dcd0ab18afce92f87c83a21cfda8e5289819b5f05888bb64063a88b1e868d0a57f75d38d37af4cc25610d856d3a3ba5b46a382a4cd63897a07011fe8f21087328f8ecab0f2d9f4303190561da5a3585b0bb874523926b399f22c86f7dfbf0fa045c8b8e0008989016226ef8b66eb44d96e22db0650c8969ed8b159c4e7ab1c85bbaaa9a255e5bf1ddad1a8bb2496816ee2dca68aa8b9ab3c8a4245241defd0c88e28cda1d573f4c11a392c588d1b89f68b0136819053e593364b6ff330145bd2ef28a9849a41db", + "14deb946dccc39456e5efad979364f5473d8b8228b943aabebb9ff5d6fe9d54196ba4ec466f0d6131a4326a22db565eaf1b3379571d1a272ee1d157e43f435b8551441a565991b8e8bbd637503bd74203b56a2d332fce42f5d9c4ecc790514bae61a922895da435ca4acfa83a04eda43aa53e2b9746c1b63b0139cd2aee7c88f82870c606726c2c74d441c460d5a666782fe8330b88b1d96b5b9dd83fedbad517f3f8c2307b75ebb6052d814d17c44f0acfbe9219951e6416a8017d453aefb0b94bc34d0afe51a4d585c7a0ee951370b69c485446895dff0fad05abc4a8ac2a76c31050969d1467730041a614f5e33373ab7ba5ec1d6d9001e06628ddf9d1f7e", + "1c78aec377e844c06636c9b6059ed8589720e2797ae53c1882027b59d575be8cdb7b77245e987f15cfcd81ade7efe51d13938e70a1c651175d5507df15651fcd003a8f4ec99bd8caace1207cee168a15390bb289d607059a2745051ceeaf793c3ee16ea171e7624489d89e0a36c7cf0f66094457868c3ffada9d7488c6168508419a6f58a741b61891b15785a1fb2bbeab37682a80ea0155a5728cc9cd77e9b2b930b94129a36db475aa066d30c609faf1483e10017076755c164f521f2b23c5b46f905742db264dae4ac2342229976071c57e7efd40cae78bf55d295e525688c2dfc05e6a328feb27ed8582199dc744f2312333aa93af3ea220e8bb33d3e121", + "16fd4891f410aee4d27b4299303239446eca79f86c980b40028ddf45b22bdfa74c218165069f2dee45047da138d2addebd9f45ef8ce004b18f356eb90b0e94ddcb9aca4fd5093c43eed8d6b2d08ddabde5b9798d1a0a49f67442e4b066446e4cdf1d4af281995ca54ea28cd07f0901790864c097f6f17fcecad0269057506d0fb5ca8e38c0746803b79396f8e80cef73916a23739429d7d6a05d39343937927a48dd9987f8cb1efda7e547a8b78e3e734f41ffbccea6bd962cd460fd8ac37cd1070916a486d81b46ca68021b70ad9a60717aae635d39c96f13f120d9c5947b08792ee69d2a23b597e019b92f7e356695c3a95c843daae0e2d268dc627f3cf10b", + "105993f881ea1c82d5f5da24120426b3788effac63b330094fab892bf4a9f4315f14ca2f72555c25069b3ec59614cd3d6b5fa62fca849626696c4253f7f2f3d3999a0d8cf56019f0d6b16d724ea711e11113c7d38cf1fb32aaedd3a6eeae27662041ecd71f3afebd791bee7c2fad5fb982f78a4fa6e4c95bc01e7c5df304360344d1aaa3c2b16e88970a7ecc31bc0208519c8cb6349ceaa3bd1fcd929b97142c81c1e7a22ee9eb6aaa186e8657c72d440a1444ce12e1ca51cbb8b8d7b11afe75dbc3960c7e41256044fd2590d4798b3b371dc55241ed56f207930ddc114b61ae021eda50aaedf68a6447a6a1309c6ce3c19c83ee1e2588b2dfd22e39b9ae9b54", + "e76093f40030a000e81e7fb919d76d9c165e5a55286e5afc50cd8d79d30933d594c682a52e73fe45181456fe75610071169e955c6468dfbe5ea276e1338e50576202b33525bc90b261a794b1a28ded9e619cbbeeda1905a264d52128052fa0a759fbb289377ae81b72d207310e3cbe67cad948f4c523076b7b35e85ec9ff57ea2b803f4ee7d1d2b32bc24139ed85c5169225be61d973c071d6ed97264e7ae363038bfc86ba1be371a39ee1ac7718ad84e9f124f943a4e47c6ac2b901a5ff3e7f52d5fb2363121397822187a79be96838e6b249a86e386240a4c6a6ef18e4d6395053202bdf5d42c87ab45b4e89b6cb425a43a6d1075fedc2c54043ad2684e6e", + "10a1a10ffc3b7eef1f9ad6ba5a95b9d2767791b6eef44f1a539f3db8c26b824ca2d94bec3dae2ef829237e3a6876b9986b94c741e4a45648a7895209a7a04e7a28ea1efefdf9788c94963064fe60f5b07cdecbb27f545772c397cf0646d1a3b5a53b799540c2df62536a6b57282f9f271baf6bbc4f21e1321a938b34f1ecb62ae87b3272c478c58c2ad8274b8c96cb7e157ce9f7fb96e0029d781253f0afd24c4075fdb73fe020f7ad88ad9e789f683120b8e26285128624762e5e1b6d299fa39e74785c451a5bf6af8c254bcf37a00bf694babbf7158eef739f983439e0569624bbdf5f76d33c0e962664da78a196ae56622b51ff9d8d53d316ad6d49bd3f38", + "35d5ea998ccf6017a5d38d3073301d58696f30559424b49a4e0b677a76303218611c1b1dfb8787979ce56b682ea07b56aeab1b2bda4c1c929b4f8746ebd8dd1bf0f94aff2e3529ced6f48f3731c2a5e214b5b9c0d850f877ed489b480724330147ae7d44e8523a731642cd7bad69922210c6ceea5bb54b798a086ece56d248bd8d50ab2be244708efd26d382dde6291e392b0391eda288b892a3a3d129060276954107d64420aef88d1e2d419997e7fcce72ff8b04bb508db5e0439056d231248c7cd6109e73136fe0355b8e25cf5ed629db23d29e7b1b84eafa0aff1dc865a003085ad1829df7857284498a96ce95a3314a08b799d1418eb8fc1c093eaf67a4", + "35851a618d5b44b7792ad8d8fa07fcf3d161c6f26fcd9d54e002fe51de2990e5edab8f8ba5594c78d6b65501a6ebb8e3ab3b7918a2c46ec45c391049b225e39eade4502a57bda373e4d416fb1b729178120ca14e38254ca4a44099117eedcda770fd0e3aaafb8b4f327d75d97e45fde39256833596c43f6895e4240c7177701ae905ae2ed842e81d37c730e9b5e9cd29abc9663c3163da96b9918cc0fe077514be30d2dd873266eb74704f42aceeed500c2b398698243c5c3d7afe6e197d9709cff5878aaf9fffd5b9cb3f0ca8b02c442ed8d3a62d661b796953404aac7513a1f2eb08ba20a10940152c6ac144dd1fa95c994115df733b01e8723dfb8f14c23", + "db281bdcf07e873a9f80d223ce57133738310fe37e39cdd9b18782a4e2532846e797131115bea347ac0684fb84ee7a32235582c8d5440e84996373bfb52d16952aa50a3ac93f627f2d42aa54c6e3a7e1b6705ede043b7a15f28f0e226427fd627cb3b88c5ae7a4d22f9d3e72f4129fc0732be04cf9b504cf6d24bcc255e552725dca2ed9c2c84e092adf19313733e848d98b9f6c2f4ddac35d6c54af904c85efb77818da0f08542371faa232612b16f697061b2ace9702e679a9e6ad2ab1422593e1f29bcac0f6e46dd702bb03b4b99ad3e2d84fbb70ae0143f3ef8f4408522c8284272b3c1a8c45ce042e0797a7ae7f950f3e91159e202c691713eaa2729a5", + "2473c5d8787284c43db37262e5fb953573b10d9e6c0849a1e5240a4772da2a2201041d42d8e91b73638d91ceb0e5fd9c4ed32f884f374059885a2c45c637aa41720ec43260e08828925848fdd30aed2b4bee6567778ba8d3a085410f420f1cc5c33a084f0fe2206129141319ddd6cfcea086c8ff5cd39af3d7b77d89a3b1d17c810f50a5a95b105da4c48c6474a1673b08c10ec0677a3fec95f2d6a7a3b584dc002daf11b9e862511257d758015032ac14188b88a05fa8b5f6fd5cd263495bf6503f0e91d91c558fef3692ff0d96c1cbeaaaf3462d484b7853a9e4b834887c3798243452e11d053759fbb28531729fdd5f290f5a3fc676938b63f98c02887ae", + "30bba4b66d97ca233e1110cec50c990b3714d7f0167c6b61a8a0591721a27ecdaa1fea710194f0738823950650bbe2ad28d70ac41e0ed6863606e26f73bf97092b6348aab78a04275fc685bacde91605bfac23f727e61eca59c63ff208b7d25426b1fee2463baea63f172b8e25b5fba92e4e7670768177660dc1be4d8498e0bb2899d7daadd17a133956980b24b39e574076ed70a287ba47bb3c1df7243a7819f7932a459d208e86eaad3c4b883566a8efd510f1b9a96773a3308a4709f8e9d2905f01af7463a1b204ce026ee528e547f967afc7e33e25b3ed91658fc28253275deaf0842fc9d888c249253140c6efaa3d5b05331d2c8120a4f39b1bd6b70d89", + "16b0fef98f884032d88b8a206f7b0bab917fc5692be38de21a648bc092c905f43ac5ccba2f7237bf0cba8b85ed5031eb47a1f8dc170bc8117f847bcb597317718679ca3f243b4c58fdaded90e8dacdc4f91fe1086117d82eb1c5353bdc613fc8fefda69f5882a7a790082292c8e8532a3cdf5b57c958cee6f6d479d1ff1493b4de96af8e44b19c9a5240dddb9d0f10fc6abef19e48f47dbe5150462493a4f39ba842b7901a96e3386ef950af1b14c049a34d3218e95e610b72026bf50ed3a7d44c46b82374584f88a3ee8306b4a0f27cfa1f5e6e8b2a8b206807e26357011be55576c8849029b2bc2002934341484d73cd8de1cffb5e980ac78a1f0c06212d2e", + "13f3eca0c6e2cd140c143e557aa9ef715c6736aaa67211f22a76ff85f2d2d640aa74884569aa93a6e8d065a2e222881c8b3a74dd57bfda5e7dce0997c5b6895feec496a9084e20d373f35f8c24c9e5628ffcaf0fbfea3eb33580e963dc19977834a322289c25f93f4adf64283b28a3b959ff22f128a0ea27b99c9dc9efb5cbbfd7737973f7daed0ee08892b81581f2fc61abb26a72a5490de81f2f49349058bb2e59e0c2d8dadaaf41060888d67ecb4c292711476a861fa113bb4c8381285ee0b73a91505ece3262562e2925a03b731888548cecbdb6af6d876280753946ef19ba1e1911486549e8bea45ecf13e30eaf68540ac35de352102998c2fde4d6fe95", + "2db3f1c96133d2445d6023edbd2ebe90f2d30b377419a339c7a485891b00f94982b39fc167767517e713d5a0e8101688e00eac6dc32a879ca01d4fbfb0e202a7f2759524a5d5fd6d58d2e7759d82c96711c49497431e90ca1ccbb15e9d9ea8a311abfe32f27dd4f2bc775071bb8114fc3c724e03f3883229e4e1fb204ec9a29f73856dd7a0e7cf6139a01f2bfe9b6fd97379378972572819d35bfa995c4eb2142b6079b6245d94c797c53f32854c5809232815bba1212e630facc6f5a57d05fdd970cbffe62b12051d8189070c7e85d77d3006c2467d15145f701acdcfcac4a34cdec92be4e96b131d5a6d7b515a16a8d25e0e165599a2d1adfafec569dc88c7", + "30b33c5eac84488399eb5743bebe0913babcbf7b77922e5cf2adecdd8a5bd32b457dcfc40249fca04485f3336e605080d0241b34a3efa7e18bfab5726eeb1d95d67dfbf07daacb63d11f91f6e085d5686bc6f82a993c07629746bfb6f8be22c2897111a2f296a6ceed02de6ff8264ca7c155b426d020a9e9162071b5e2b7f6211c702f3b16dd3c176d8e6abbb6b7aac8d51b528929f94c52574b0d8b798cc014e1e71b84476fc6d8bf20bb163cc549e58ceacd40eb23805782931f942a5d5ad0943372d96cef0ac9edf8834c9f4f0e36f40bc281343f48e0c91173b529d09a5b6276164cbb3a284896b9161a084dba21046494946bf55c4287dcbe042b67cbb5", + "3bef38645bc84a5122aa18081fbc27f28d00ddf068be036647ff4519d1681dfa9e602475eee3175cbe3ae50b308fa56cc979f77f3f21d758f1baac3686884b11b026c2f78cfc3da723283baba900a7877bdde55221191ade4d97fc76e94f136d989ecc4609cc134221bfc86dd99c207a374886f99952ef20de895af2432a395e3c26e789a5fc8ee91079290fdaf8bb6f35d97bd83f6830cee715eee8a81fd588e167ae9190a15747521aa9973a9235d090e88e893d76b2d90a090197c7a0413627d0b7aa56b1722867e2ec0e1cba6a4bb586cdbf8ef3c453ddcf4a41b5564095b190a2276803b14e1f43b73588d606c3f6228d163dd75020743dee9642172e7", + "c6a5d8948d36a99d9e8209b26880e839a01fe884540663db0f9c354f017e8dafd99d01cc129cdc4ebca5d1218836ae932d2772ea732fa574455fdda83e50ca1e0ff6e378a9e24d0e0331671a2b2cd89196463361ab4a5266a471d317cef673abef622d492674612d03fd18480b492d9f884043705c9e4148632c3e9e2e15689f08491338f14265d0c0ac5b305786d28a8fe5dc26b7c0b6b416b2f5b505e7f439e05ff62ab7a15400811a0f57a147bc6b16e1e5bb950eb6b17ad55c946e15a507d42ac192a68510cea6ed743c795f404535d61b13507d82465e991efb68112a5af47f849fe43313c8f80f86edb84ff115c9260ba685bb865bdc72b76ab2cab0", + "18ad35df0cd0c57bb64113e2a7e89b732cb68ca575d6bb0f0c8575a1288039ab350450b3dbb504205b0db9bbc129bb6aaaa344f3b89e3c0fe349651157f6845a566bcd586f8050ea7c6c1878c46cd71bbf5c2119abab7fb192269d9d83e39c2f138ed00cc9e1ad5c5d7203949d00f34a12a846c6994bc8f90c99e9b6fd5d1c99e8d3f17cc84db3ea190fc9735b6fb463eb9f0d4c68c5edba86300ffd98829de4d95fd5ea95253599751e17314c794ee3784ab05d78836ea47d1c65a806212e78028a35a4a5b659072043aa15d7237db20969e047735f3d50f7a02c44e507c414ce2bab4f0681fe1d2cc638c686eb54cd82e2bbfd153ac7c6a55074074fe18326", + "ebf789892f5aaa1df063d30337dc429d443585189709afdc433d6d12eeb43580104c425c8ba9d815d8a8dbb2f25b2627550fe6a53687adaa81b6e85558b21d445df6ac69fe2100e477f3d353f3d045bc9a8c888ebd03061ddc092acbd443c4828f89874e0f5b7ca098c68c440441eda15b3c13ad6b27c2b6991222b86650cd9ece912d0afb68e9c5bbdd1e6b9315d1d0513a4efd64bab30cc0e2ad6e9d6c5a1badccaad28e7447671b7048b5e41f0cdfcf28c9e04e538955ebfad8f53138221392c7775ed1a3de5c4b448163519b668fd7dbfcc77012aa5a7449d0b55e33a040903caeb3d2ae5e5fb6d966f6ff8f8d1c7de2b7261a33e8a93875946a9620b25", + "2e1f28beaf60bc262dc16ebe28f7508c69ce12e8f06dce56f018602fc8c615349e6b086fee3202d60d5e155d4517a48f9c2e0d154b77de84dec7683a224087102e75f0d60e58c3585baea9abe1dc8f59b2bf3bcf28f84070ce315e97df98c63f2fe1f51f987d3c4974ad783c04174e2f94d6530d5bafaf9bd6abcac79befc8f5ad3872048ae2338a353c4ea79e1abce586a757f1bc147059925959e9129a621d4ccbbf3c7b01a4ad8e26981cab409fa0637fc77b39773449aca37bc665b7ea973ce786879c1fb5617cc5ad743c95f3b9b2b1b1a8f56c12a5ed569e7a78a912e315213d03bc9ef4c606d4a9d303d22e734ef6b9ba840168a0c6527fab746c4a83", + "26ff311a6486a1b313824c3da76cc1cf39bacc110a90b3372716f77d444ee48f067ab3b58cbb38f9b7cc0d338d48c7091d95ade78470d12ef1cdc615437f52354b585797e6c868023d27af32090cd8e035223376c2e90adb005ef32c19de20219a29ab09d299bfd2d91988f9db3ad2e124cfcf9c8595b24640088a07d632517762ca58c403d05c0431bea690353bc1472aa6cc8a36c72e272d2219078d39479e93e5fe7a9560dff4410d753c72f1d1cf51f4ae1bedc3d6c4a9e467ee3305ea5e12607eb54fd264403590dcd6427d82dabb24c7bb233aab99af900e44e1311f28c4010a00b1283e4f50df480a06538f753527803a2b0a5cde50d70ae509502fd5", + "6906978f0ae23ef873844d4e2525864c0e7d17f64cdca07cd9ffd6e4ce359997a6beaa92614cc9440111ba605723b80a08d09ce46850cb8072ba84b6c0a444240c3eed097037f51b10249e20cbf36c847e411e538d8f808b7bba7c00e5e059be8cd5bb07635d05ea4648441565e9fdf79aedc744aabf663156bcdcd4131a779331cf46680ab0017a33d285ee841966731001b3743857204ff6a4299dfdb25ff34e03105ad35f3898839681517928425efdabe19ee8a9c49bb35cb9dfca01bb67c983eaee399f04d64b7f69da8cde42eb0af983aa37d98e03d0daec6d1df169f101e9f8eaa1b5d6880f14d32f8fbb6418d21328cfa6d07e6e492bc15b28bf27", + "21ea3765c576c2ad9b30e66cbac2cc1d2fc237225efa93a56c4ec4b76b35aeb39bb67a61325020197cfa7b53dd62b0dbb157991600f64da241ae023306d8a3be2f90e7f9ff682a3056da6af1b62bd6ab410597166763ccfe561912d317e2e4a458f1659fac56f6174feac2d3d148db258445481e5265e369f0ef83095c115b58ba83ab89cae4c69ba95f3bfd427fcb26554bf6f06fbc443d5f44aafab71dc72c05707e4363b6cb511656953d751c9b49d37f4836acb788e0273f470bccca7d752bd35de146abfb4304ef280432d455c879cca4a32a21861904e567f335c4c8c01c8dbedd14435d52c82dbb19a51801931f5b81bd31fc48c96b6d0436f41a38c8", + "6c5258e8804f826ef3abadd6d4e81348b6b008e189c368bdb3c40d3348ab0064b11e917ada9fe81b3b95557966e1d1dd3f45e5cc8e63fc897c260b4a7f4cb2f85fef787222f259b61b4545969f54539dc279842960d3cc25cdbba8954bc98db8830db3974ac06678f73dd6210635091f8cdcf305abc6bbd7d24643c3500e786e1f03f4b7481d8714b73486ee62466f8acb6b4ea1aabc8aa8a5c72d563384db488e4875f2a0902d146a46dbb0d5d11fb1ebd72f187fd4e0239a3ea13737f15af7ac8354cbe2b09e657cdb10488d43457183ee1a646fddcad41869315d4b939e89dee089ba18c6c378e334350806ee236ce18c3d1bc3d71554f70581c066e9c13", + "f3402d168976f2caefb379823e14a5fcd4de4f7b78402cf77cf9fdcaf18cf3a8e4c9a1863c357a5b45252c019dbe875ad2edeb38b80149c6c2dfe34900de244b3e7e2e8c4cdf9ec4e6af4dc45449c019f69dc52669c8110d28b06b48a7ec333cae9d49c77dce42d65ad55b23b87f5f62bf37e7b351c8ca64e1e7c6177efe746f90489b568af0849afe77b705149d6a4a5f1b180405002342f52e71cf7daceb8d37312669bb22f1c3c799a27e7a983a525665683381994d781a945120075f1656d6b34a9f9718a78c135ded788d3ce7b0c8fc4c2d6a1c268c9c31b10e3dcba61eb8c987bc9ad55e03ba40b4d3e22a2c8ad7b77dfeb966d6efc296f09f0f18a1b", + "2ac3d4064ea02279ead2e8756909db36ba02d8d0fac4863b60fac357e3271fda2c435d583376fa6f7e31f891b60afed8d82e63c991198df41af79a8a82a7340253aab836b2702da19e6f4ca81fb1af861fb543857357bb100d6fbc874709e99e1b0f1e724b9fa49bea3fa112334b32fdfdf3b9c678ad727968c6eaa759022dc39dd535ce6a8f0169a7ef58f8b135e44bd8388eb9a8c491805732dcf3a0bf8a1fc16fc4691bf5c8bb6b9130a97d31d2deded25f46f8d762fa4f9b9d69abf9f1506fd8265f581f6862d160fdefa81a4bc87387cb08c9c92e84660d0ddd2c8217315bde7cb48b2d1a2a9c2fe1be2e0808789abbf3cf1aa349d81a70a659b75cb556", + "33745fdf076dcbd53113d0e12fa1fbc2a32e98e272e53d53f4d0ab8bae055711bd7e5e9129fb837fac59ab1310f3d639d55df0baf576a37eb44ab61ed34d1ba61e210bdef1a1e194b388ac8d8b3024f3521b580766aa266ab3302289d8173db40ebfe0165c00d4cddb272a98fa51898ef6c60c783e060624c24a5c6de630c22e5fa4b982bccee09725ce872def216c4f36d107f3292c12d942d5969323286121334dbf5280f7d3e6d79fa24cc7009358a362962d29cf12dd33401d4029886a1d708fc46364ba9be4d99797dfe9bbb55680dc6e70b30dafc383af2a6f1539467c4eabc967a4a67613fb7c8394291f14838a63e27c82ff7d3f25df830dd723704e", + "3192cc313f32a484bb6d73e10e9f91c78924b221d9110cf21db07c159eda5f011f3c0cc899780b76a09378f41ae160b0e8be199511d18128a01cb857352a7eb1707ba6ae6156458f09c7678d4b52884b5119d34fe880b60919be8818b689a3c0eb64041d7110ee26013ee9c1e71bdcda227bf14f3232f52a186bea2ffac97bf37a075805ea74c863839cba019d8fb9d521342716fc5c87617de6f2e03d0fe3343692bcf75c51dadefc8e70d2613299dd8782ab73b90f50cc2b9c5d2a259825cc3d1de130b7b4df9549005b2e2a67ad9b38b878d3f6c810d5a8547b766c806d8375b0e81c16f0921da0d342bf38bee1abb04b1a8c7b49a3725a59472c8cbc555d", + "2c947956070f315c09309dfc07d79dc933ca2d6d485019df2998bdc51aecb9aa6d7f1238c0c72b0304d6d805cfec57f1341e75208635ce6c78ad03d5272b2a211c713f26b481ad472d39c852d8a7dcd47141926e44a7c7aeef042b80753a7fd4e33eb2f4b719f0af3e1dc93591b88193733576e8541f0580e47e3cb78fa6532c2299c1dc64348d82332bde221307731b69cbeb05fe4247bed335207667fe8e74ff86135b3d476be7607c992412a632097f2686fdba829190166805eb5a9515838e380945956cacaaf712c2e378496a65cc8c7c535726ce8604cd0586970858c1ee8a65214ba13d34866173e594d344638e417323420b6ae8ab6f8d588967d485", + "f9aa464f6d841f08f7a47dd73955108006491301cd751482cd2ca0720083743624291e07ef83dd6356a34ae9b23ccc36eb6d4343f36efb6c5581ba528a4b6d6ddefc00f2dd6115329b312909a77aa2397fc3bedc2a289c2582876f46a832568864a149bf48658b1a9446a5f6fa74684f03cbdc44f8c920a17da42620fc6a80dd7b2a690988952ad5079cd055052d5cce8caf29366a8789ce61b9b1496f1a7065b1dcda5f21917a9c45098adebc4d86ad055b063fe4d3b7f1b8ad7935d0ac7d7f630fa64353b1090ee161d3fa4e76e774fb3aa886e12d84b316f1e0dfdabc008653ccac34cf96c1f400e1206e588bfc5ac241454b5273eff02e165e037e8637d", + "1cbae0e8113b4ec7d350b61be4beabce0c6e80339b7ac0d8a8e45f31f5805d25221e21d085b7d6239068b526b30cc2a485b76f596e6660577166773377cef238fffeae935095e9bc5f1e685f144d6c3c703007bfdfe5e0450ab5ecfdeff9c397277b7a2b3a3c1c132d7832196c1a5fe65be32e7a09833178730ca2b9a1eaff91158c74216c8ad35bd95a2cfe9e37fab37dd1920c9d457b276c8eef9137c4014e75d942ced15bc823f24791b30c192bafebf6d529eee05d70f241d8a495af5847a0a2f0527e0b36f11ad72c28229a80f30851920c8ac341b1bf059b4a49f05cd77f980b7074d2464b1a6984765046d925f43b99de17bd861e270c63bd9bb9f44c", + "23c4f47c61109a4bd0b28166344c86e049ba4b5fb665c2d6e650465781905c435a706f6e7e5be47457c6a0096ed34ded2191764e03b200ff407d85ccaccc9a75e8427cd9fd88c16993567173658c4a5074a0c0a0176d0273aad382872128dd758d85e56c512aacd3fdd30dd83af828db2cd8e2f545fbb5b5991ee23e45301d33cfb7a304239fe89f21c8313ecf690e3ad6da3918be5f07fb36883fe086a8aca1fedc9a178a9a5b26ecf86120fbe1098419b1604ba20535e4afecff31cb566bd92b05fdc5bdd8e94c08677a589220052c47212e0dbaaadaa47bea6ca38ca0f20f89575526b2544c02f831d13252707ed4847c2eb5f04ee0222cfc5b000ffcb9db", + "28b2f48b1586cdd9648f2e2b1c2600da262123bb72bb61ebd8f4c13afdefefd1be5d8194c9d868dcca2b1612e0c1f5eb3ae97385e6bad791f691c5fe5b0a52eacb7b93fc7ff953471af094295e388715348f833bf8c2a573e92694f7cdf173dacba79dcc6b502f56ccdd56b81ac1bbaf9c8fdb1718dc2d84be5237b1a3c08f3379012340f4eb8445124b01024505911003e7f5a8a5ac3b18975562dac8d1b86e0aa988473683e45a2c54716c78a0fa03681b53ac5c31fe265f8fea4344358814e2766bc193bec854dc8a20da2537b86c735ef30edc0390885a7d479a9e389ecb0c59f1ec14d42f89b77f1f9b7bb7f11f73d56ec94c010854cdf6033877d786b4", + "1d8569f6570b804b6d209c0c0b77f634ea36470b0c281ede4e9565cbe38d20d5126ffc1432b2ad6a20dc0aef876626e9a50a97d44ba10ef5b936a203e4a083dc08ddf53916c72239d3fe1fe44de36a8b1c2e6ef5fbe5c091ca5788b597893f0feeee48d7e3668e6a5b23cd6c9e2396fc03f09b3987d9b4b38a54465f1e366beca8aed3cf196d928604ac488067565b2dfdf063e46f1bcec0e161d6b7975c182c875ef36aae9c86cd3db6a38dd18b96fd68d9139aa66a8a771a4c5545492d0d9d15b48b7a8d2ef6fb1c3fea5c26504170ad62409d947194510bde939848dc09c977da5c6f05a29a2c9e1aa154ee97e7a24a692602cbfe7bac4f9094784f5f35fb", + "2ee82de6693c2fa199b8ce1a4609b0278c7a8c396f88bb6c3584e462e28e6f8c19623d02a5dfc6f0a0959457710beca8c118dd331f94a7969af0b926d76712bc211e97a1ea08435a3a5b8533cff2d72c6ccf70ef39b6172c14c3da1f5903fdc83328c74847719e200b6471051dea4078799df7cbb9015653ca6411716eb330e378482aac034cfc20bd7068b4533992e8d03eff9aa1c0419b618b6ab9bf5c82e5d6d9e4a669de2bfdd58200b6cd337bfbe560cd6f287448a2d4b2d164b40c41120ae25c9686cbd609d9cf7f31f7db2dd5f081db6f17d31703308de494a37bafb5637ce6bf14360cf473eed5b820021514928b0134e736403cbd1b7c2c00379599", + "b183fd29037ad84b4b4558b2d25eb59492554dc317fcce5999d6669d77ceffa681adfced65bf18f1b3af0e000f77bfdd3fbf15312731d4c739d3320eecb3b39ace66cb020b2c12e8a55078328294bd57be8678168f72f0ac0f37a3caac99865016665abe402198d9111465a1c496995d5dcd0c5cd14c6f4b04c0954343164bde198962b603af5da22184a62021a0a93d4eef4e88ebf9d93dfe365c3e630ce6e727755fc32c4dfc3b97fb3bea7237749f6f742ac93d99ac32c332e5043316afcc30d1f127fc466cb826a66278a4b80d7bdcba2d91270d8e3862e881b38832e30f1dd0934489d6d478c0077226bf01a2a1a33920b5527e116a8a14002f0b305cf", + "2e36daec1fab897d9ecfd5785edbbf5ef2bd2e76c08e5675f15710f927f37096ad97518543da443f6c89302584b4b833a03c9950e55ec360732b621fb1ea73ab8ed2576b164c4eeec646dae83ed801f853a5662403c7304c45f7c76b03cfb3c01380fb7cf16c7de1383ff9685c07e518bb3ac4311af9219b85b30006a8f507d7decfabc42d013dc6dc4a3b42502e5e523db4266f176941ced1f811e88e240c4d0aac9dc826aeca18e241e8bcb0d7c52359cddd3e66c104f9403af941688bf9f288ff4d9fdd509a0508c3fb2ca426bd97bbcc32cc7039da6c37deb0b7fed599d11f684fa435cc38096257473fb756bbfc64a2773a4db1b8cea0b6f5da2c278c9", + "978597c955e424c822df919597371f93add839a62746105958b202c8a2746717ca9f452d8c04263d91798697688e041751a093e18346ee12ee0626d85341f55e42f6857ce748d628a9c1a06f8adc9d31edcbc2679c010f2e6d008761dffb88756671f9ac1f2a3076929a9a54c2847c8dc256f95c979b6c67eec84461f8409b24b7c201f2f816fb383a60806e294b2e0b4e5ff4704ffbd36d2b91690fab893267476e45f7e7cb8ba4afd73be3f84b88b8c75b8be91ee412b077ed95047c8a3534068b6abca18ff8f6ec2c1ebf4965af8319d7c4169e646e4d7ebfe58638e49b50baf3c7750519c2dc763fba46f3b990a199d440f7a113a2aa5d7e32a78f20873", + "27d22e3153ff7429bfd03ac3efd426d2220c1892e6b20227f2fd284c87d3451dde27355e92e48869eea019859fa8c89f3221daa51c231ac6e8360d58c3eddf7fb9d3090556f2f1c7f3ceed2d72efaf4182e5d583f834a509e75d2ad9537fa96c65c179011ba52e7a1845af173c1094ab4910af1aa79de33d7a8c643877d5d92ff26c752c43405c0fb3bb29a20af70249d4690aefe0b10f91cb6a0e2d86840edb1a3e4b7c7d22067b7c21e134341778b47384a616dfdeb381bea69d89a7b9626deea25d5987c8ea08afd2ee66f5176296566f29587afa9deb243d24ffd01b16bbddff3d9270cb783d674d8c281cc7e6a53a81327cf5db99349b73a6dfd1fdc20a" + ] + }, + "factor": { + "challenge": "-5da2d23a42203051ad5aa4b7eb8f084513591ecce4698fc9c166f98be64536e9", + "inputs": { + "n": "bd276406344107286ef49a2acde336f5975dc24bfe350d57501071014b374537099933214fee6277bdb4138a1b5127a2f4417c30c9b271dc03e86896522a1b18d25f545932f91ceb5e037712b1d121012c1649a6d07a6acddb225a6804e58ccd9fc88d5c872ed5912c5f4179747b828a3a9740331b0d4e2157ac88b517c8f7e01dc6475d61d60194c31faaa5ae381c2615d7f1c4abe0a3e544811ecf0d1494461066b354a201a78e40e4f289accdfb15445e1248808a31590d7a70659f2c55721ea4a821610bee961924a3af65a0a601d3809d2bb9e223b94c96b2f2ea926af0c2b88b95dd334cd683f3ed3f5c446e918e9b23d219c8a9f58631cc94aecccfc1", + "pk_n": "ab9acc348c6290f126cf3cb35e29b71cef8cf1c98d21f22276d540efb4f2a74a722d2b2ab6fd3e400621de109fa0c82104a6111d476da33c679fd58d32e32551e1f8e4b39fabd9ff7c6e5bf76aa5b7ba72ca79bb72eb68ad72975a6d1cebd0bec34cf56c9cab4d39f6280206b001d6495b6e1c58f3b050be29e078aab5cc45cc201922715dae7f72bc8810380a38c17b7838e6a18b804e2a25d2d22977fa26dc63161130464af47dd5c42dba70a85a0bfa2e3ca4889abb3cdcbecf75165ef6345ef1e58f9929df65ce9bf33a53e8f1ef18c73231c70f21a30c4c21f10693eba687faaf5de5f3b27e020527539b3a8e8358a929bca06c1ff6c3a2720ee19bbcd1", + "s": "f21c50993ff18390db9d37e26621809065359c0ec1a70ec0b90b71dc10a070305519e2dacb54dfee66440cd4219c0bd0e456631c0bd326627c1005f36e02432b03447149a4ce0e62556531fe907bbafd11e1059af12fc1fbfffce9205222e42b02c18622e88eb0dcd22f098a905cecefe4672e7e8abe97044f1b993f5294907a5d595ec23179e82717978d594f205c5c3e904512cd998522b933763b3f0ae56ee684c1743ca21c86b6f98f5200fe352f3c2bc5641d8146077755332834cfa5ff2663af15ca0b7a239be9b661885be6f39455bb4be1c3b54c2d598683c9731ace5f19ea7ed5c1fa85f8e304a50833bd1a66157c92ba2d91f021400d736e39b05", + "t": "23356a7ac492a79b204f34ad22f474c3fc03f1254d2a4d24ecb68a670f1cacd6c2d6e9522edeb8d8e58da89587ca88ba878bd2d72ed3ce74104996a937d7a5b8e68b26200671757e110764c16b2ac2671e03c56345cca8bfe43eb514a8c7e1f45d05eeda3b4814ce63ccba37d47756efc7436dc899c4fb85832a10d05e11bd3210bbd0223c19fce9535c0d3dcbd3cc29797fc16a25e5465c400fd0ab9e93dc4c8b3ddc0e736bb5034bb20ebee475d4a837979fe6dac91f967a90405268ab6293498592c15d8c556ca5e893189f20cb4f93618818e19ea2fd29b44cb3bd3afd7641d23eb22151f25f37f6c318531d2df923ed299444883313bda323a591c695fa" + }, + "proof": [ + "64d2825ba6321ec6ffda63ecce9649832a1ada67a9205fec81c105fe98120a44481b1cf9d843907dbbeacb880e680f140971ee02a0f20a4d85b12f50f394c6c30c9b60f70e378603172b192b5adc9aca63fa604b2a2280ca1d237dc00e367cbfc16ab286b1485c72f3ed444d9b44e7c9296305fb99bf19816b3e6c63d50b4205747d55455f35cd94392a6bbf3e3937569ee99b95dfc38bf3300d3f092a3694630a3a6f6a8041bd2c18a4ce417ebab336fcd0f071f03fc3d1e16850aa76a384e4bcc9cc5a53d5e48f8207228a721c9236523c15bbaaa11c688bc655e313c3a5d992e63f1065b7ca35739dbf17b5ec70fd32aa65b27ed20c4d563c057162364d5e", + "105c6f08e7308293650a162dd8f1e3b15a1db4efddea09614a2f88c61f37fa6eeab6c450a08f6f96f6b829a09d8abe77fc7848b377d4fb7a6869b2b582c670564dfc3c8e8dc5063370727f625ad09b4b6ef9aa72f347a19b8d9f0c4fd50c560b69ced0654f54202acbb6894060b43b72dd85062846f20da9b710e03433bdf841577bfc52ed4b513d22d8b191221efa445bdd8095ef33c775528bd81b10f5c2244753adb3c3e7c436c0cfcc47e2d2bfd6e107f63c3dd649f67ca158866f2b07fadcaec6479b20fcd33d1f45484d41a4b8406a124cc3fa9735ee574d955f69a2f91418b9f17f89d1eeeff1f08372c3a00bc22fb3fa281cf34c343757a26bdffc76", + "68c1c5ad289ccad6d35fbe52f16052c5d8767b31d14bcbfe3e0f807756edc299b3a1371af75ba8f5d22eab9055132fb090efe5542db6bd38aab3154e10ecf69df7566767cd161a6ff8344d8b04f7de2532c3f9df84c336b661b62427866666402c7b3ca54d496b02d3da2c7675798e59867c27e862995fddf441aaa8c0644fe96a823aa9dcc9ebcb3de5462f7bf3d096190322d90968f79cb4d125e4bdbdae118183066106bca27431d90fde753676f96221247b6ccf30ea9eb2748de1dc439c3acfe52552aa4ed3ace719b9b986e7721c26bf9e1c7324c4d4f102ea5b519c97b1fdf9b6b3a88ddfd9a04e2854413315d47fe44629763a3e1ebd76cf2f1867b4", + "2f5740c595dccbd06ad968dba7fdd5579e34dc12da6ca02e02d2da1afb59121d31cc86eae1d687106307d86705b836adc9923c8036ab8031e3cad9267d536b6f17d4fcb7c4b348864db98119d140a8a2138e303b45b1d344f3b1bf5e93581c493475e8a9f441d2dbfda187d625f12ecbf7914e6c33aa9ad8ff3ff9691707bd24e8bcd552eabb1e3564f590ba4c2c6e3288c64a5ac47728ebcc3e9757d734232334f3976d4623569771797ee306f28d9f411ebab2f5bf13ea343c6e4ebfcc8724fddd39e4b086e014fced9e92e6ebb81304642508e7b146c134ff14ae9a2b5385451d0f83cd17c483588af8b90f7d63eb434b71b866fb0beace8ae6841a0f108d", + "b1db2c767a627fb1d0bae8c3a076b89c81f68d3036e7624d9b3702af0adc2921e0a1559db0df5bc248b668ea73788c6480606b044cc1501dedda0d253e8621434cac5533749d9c54666d53ab4abc8f781b6975c804ecbe89d578912e1a68aa6d5de24044f5a9e6f69720b7daa2f64f460a18607bbf05e6f24cd405b5217b9e7e74c0932a413facb56e96921a5506c323551953b6ea9331e352c5a98d5e1cb2c7fed13d9034fe0974e6b239a28e538b3e4b6ad962e927977ec93f291aacaa010ede3bdb8e7a442a274572c8ab10e5559426ea2457783afdd71e9b5f9da35d3dd50b03e2f0e5da19a8d056181151d3209ffdcca9e1783b0a0b7291ea3aadbd3efc", + "3ea5147837ec90e9c8723ed7a048313f374c815b3c11b9594b05bb7f6f2b3d0594945b7d054189011fe1db60836fbc6bddeb0f3e3ef3badbdf4b7ce582816d17b0ae5053044745d6d34dc4f4d83d9b47f454121476ac041b2b23377a0f1a64913cafbd3e151ce9f9b9fe2fa9b2833fbd5ff71aa41c9268ee98339df6ef2d6554e49c224cc7ee3d34cf8d024597b82a2a6ed36583381010f34f42ff1d0bbad94a7f88a13872e7b0a10ab4d980faf2baa40b01ee98797f48b325e075628f010ee6b17f3b4b1d0a68329d361d9576fc7abf53509e0e5789e461b1b15f27bbf65eaf4e9440dfe3e799ccdf4894f75514ccf081a127d6a3db27502feefbe66378f8cb8565547763f583e5eed2a8fda43f571f1a9349e67064b02611c8f267cec0b4804ed33e2ebf41b452ee8ca5e7a01b8553ed9df45876022a880ac550edac2f38a0f79c14558a9d7f75d860f753310fb001791d001bd6e35cc2500745ef1bb90f398052c50e74c9f6437b56f5c65f26c1f2b1ca1ddea5f7cd011757773d7c318f028cda55cc528147b9d300dc018d04d55ccdcd84e84cc85644b4c67e9b83d9edff39518528963ecec5d01e6a4586f4167e362e3880ac3e211e497057a68aebb19a9107c27c368ac16df06614bb36a219b63d2558c2924c6b9b25d0fab87878878211296f9bea58a8a3c768b347ff5c4ae19b35f9d2c714def957e1d67c9efee81bfe33aaa39e1777e19d0222a4a3cbd995fc80e20a41783a2f9f7762e92af3931c", + "-41ecef455a1cbb5fc64527884357e58f6eaf55b3c723f00ea22d4b5a9dd87c8d0edf6b019c63489b7f3e2052b780a3b1c6d35a319533e71189f632bf6cbc86401b30d05c24183ce6cfb0562ffca0f58114eb9b7d4b9bb4e883740b3523aebccf45c1cb5b3e31d0e629ba5ff2881c3bc45819b7cbd57f1c846c4180dbb773d69c22b880c17b594e33379d2912022eea5a339c25d6bd68fb04f4b60af40ff85f063ce3fa29608bf1eb667168fd5827f3c0f1fa86651761973452e2d2b5ff6032517bde6ad3521a88d57dc4f372056435d56cd74f90680c84aa8fb54ad3c119bc6a", + "-67113d0decae485cbe1d25346d448db650f39bf9d309898c7ef1e4debf5b558a02b28a822b5b3f3b4edde857828f3ae75d54c295bf80b24c2ffa8303c97297606faad0e27248b1ab3fd7edd061c53a002b0ab31b7d0b243c45b7d87c217f0398201c32d4bc092db407b5be66fa616dfe6236f92341e165d760afe171b4ca4b108e07a7afd478901631bb4fdbbfbf8885e19071e19b5eb6aa6e7cd85e7bd5b7385afa872ef37413d7b5b16ba511a0c55fb0bf9eab57a03c833093ff584d0098426e8a2927621c57a1d04e9b4be27b91ca35bc39b87e6078b0e28efdd2b6c9f882", + "2c8413bf4edab0d586394ca64c62e04ef30fcfdb9178967a45ddbaa34d92cf8d6e36fd04df73808112efed625e410d0638b686f2da3a6b130a05caf222c6dc483790aa7a6ae33a2b4114aa3644160570ab9fa6d520689bcf5cbb2785e60b1b8d0e58f32154629993e69c52317d86e471f47a29418a3d5762b100818b0b3c536521142b653e5036163ed15047beeb13054d704b5254f1d333fd1c8c8780fa1f13e00d1613e93b75ce0463fe23bbc02a0ab2f572a7a6ed02f87c96a10d2e6ae924ab20d1ded74085bb6fd94eec6c2703847e0e8566436d0c7c3492115fcaf5048fe184f80798d8a3f2f202b5c7bb7be26e7123dfe0fcf0c76ec3742fc49ee3602ae81eb4699d9e5ef7211a5e4aa60d6504b4d5f2709ea20b58660be321d72ac44559affdda687ec26c21a0395334f240a3ca426194235968e96a7d9354d552071222134e616da610cf27c3815aca58f8b228d99902489f2d3fc101430c5a297714", + "b98750b3aa61bd000ff2d1ca7182f18f9728f08b3874683a4cae9715d6cfcc173013ea6e2ba4176224213ac35011359c978d44875b16a50bcb344b5de1787e8fda5e18468a4e8ea00a7686031f09d8ba77be37c09a839c9fcb743c64d5779755d3cab3743d5ef394b41cdcf3dd2202a84dfa6e4366062779fa38c5e5a38de74704de294d3cb1509e13d0716e21acbc38b4245b26a67455853a1f033ad3264e9a9013ef3189942d8b74c0490b984ac73a8d558750a7f2bb15676e0ceb32b801b70d72ff043b28bf44ff65369119796c747da284a458d72b5f2f75250ee57bbc1da25023060a03e55e91a672ddd50f5b99a19cf5dc5aa2a05fdb586a0db35ba9486d3d974993533f74a2c93fe99bcfdcce1b7b965856c4b57f2bc041281be6db87d18375e8faa047f1ca8737e958ccf592fdf2a25edff41cd299016b8e5d51fce5387ad9faea1185c03f6e8e9fc4be510a13566381f38103ed56286f08d70d2968", + "adc6288b7be64409261c728218d207fe2ebea429439c45aebad69ec71a489f365304d46d18de37d330f366b30425592dbe341739371eef84fda044081f43b423f54fc92404939758b2afa61d132fef460d1fb4230b32feb3133f27bfb955564e2fe2ee26ed13f076de521453e792adb543805dbb18c75f3e5a86ac5beb5483fa367ad36a13a3c9dd77de77a152d95da94650c474204fbd066e9825703089929e5a742b7edcb54d256863a86cd640f140fbfc4162151e8d7d44df62613c17ddeb055ad180d69b48c64fdadd25c3dc82fdb98fcb95f86a84f22a73dedf722a01725922a3bbb1c61415b2bc9d123b0e3bf2a3f6c8eebc2107ac1938300c5700d00c3ab4ce05f3b55ba3562d3aaf975dc9a0025dd5ffc5313a4fd29bb30b094bf64255aa1e605f4f2a7beee02333ecfe53881dbe47433cde3cb4fa6d82a0366bbaf8fd1f1d306f0b313337cf0b9e0ff421659885f5cbb02f801d68b0e3742332b08514fd0c2b5138091df9747fd5eadb0865c5b5b65c97866ff0d31d9a36a5040ae52fcf98c78f89fdfafec7db10a3c5b53f785cf8179d0bcaf9a5b02c27a6e7561f970ca4b5b4209b2a801f56c51aa5c133ae8fbf767e8b57628cc8a1f3f334113ccbbfba55e8c879a4fb5b81f1ff537760902db2b1b764b68204d82db4e638df1eb84082e2cf238f49aec363eb5d29b5704b4cdbab6cfd000fae602c93ec40a78d621c2c594013a2b7349c1ac7bd77a202b4c2a635352459d39f1f87cbcef46319aa7b66a65bfd7156ecb8ad6223cfa50ad4400252bae53d87c7f6faf05e5cd3fe76c825fc8cb73901474204ed08b51263d58c8e12b5d02c3a7b074f0b49ffce5" + ], + "wire": "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" + }, + "keygen_round1": { + "wire": "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" + }, + "mod": { + "a": [ + true, + false, + true, + false, + true, + true, + false, + false, + false, + true, + false, + false, + false, + false, + true, + true, + true, + false, + false, + true, + true, + false, + true, + true, + false, + true, + false, + false, + false, + false, + true, + false, + true, + true, + false, + false, + false, + true, + true, + false, + true, + false, + true, + false, + true, + false, + false, + false, + false, + true, + true, + false, + true, + false, + false, + true, + true, + false, + false, + false, + false, + true, + true, + true, + false, + false, + false, + true, + true, + false, + false, + true, + false, + false, + false, + false, + true, + true, + true, + false + ], + "b": [ + true, + false, + true, + true, + true, + true, + true, + false, + true, + true, + true, + false, + false, + true, + false, + false, + false, + false, + false, + true, + false, + true, + true, + false, + false, + true, + false, + false, + false, + false, + false, + false, + false, + true, + true, + true, + true, + true, + false, + true, + false, + false, + true, + false, + true, + false, + true, + false, + false, + false, + false, + false, + true, + false, + false, + true, + false, + false, + true, + true, + false, + true, + false, + true, + true, + true, + false, + true, + true, + false, + true, + true, + false, + false, + false, + true, + false, + false, + false, + false + ], + "carrier_wire_sha256": "b14b6b08d96aa6d15159ecf8d4c8fba8a55dceb2847610ce62796f48ce93e35f", + "challenge": [ + "8c45f36fadead0125df03a8e4d27f09e6a391805264707d543b43bf6a7753a4fd8f42aba037fad37f7f0d625c103087064ee4f8f8f9b56dd82f72416735306b9d9e904702bc74e60fbd4a53863fc4e793fed242669a23e6dec9a8c1c0a855bfd855d5185b639f9f3e161b1c5a13b009288b9d9ac1a9b2bde9c052c29d131b5aaf1cdf444a0d90fd5025c137661ddc7c8a09ad4a1d3ee12f3961e4a4917f571b8ec4c5d7f5501baf16cc761145c2a54fda10eb43cc8f673f1e738643857d6c2c09ccb311f171a4a2ef27446a81272fb7e084a40a8b52c3e8c7ec94162dc88018f8183564a8e9bcbcc7000d2416eb5b4e8c26ab7324867dcef70dfda63a679e2e5", + "9e200926f6775a215f672eaed7fc53e840225ba1b80a858ed5d994668c8c0e66696254766d3dd02014fc68b93f14fe963621b294d7968b9a0bb9fc23167ea724f185365c8a02ff26143c52a1f2450c6d872bb7cfba0e79b39fedffb37bb17f29f6c4891ccce3e29dd80b4d1422e7bf69e232246533cc2ffc5a513c6e67f05eacd1f020d280e6c3a8aef55b198756b988759a843e545b200b9e2766c369b69518428a122aab2eff8598d325c2f5200b170e1e6621f4e3ee6c25c4aa9127db56d39606236751240d189bc071e31f030639e4ee250e1a5ea5dca8677a670da45ad2d5d630c86657a315fd496799f9457afe2ea3476d9b0ad85f4f50e225435b3ce3", + "6c46d48c0907e8216f0bce8db446a145a4cb74c6f23e3fec8e93f59b2da583df5a8559730e278e79ed48944fdfb63f137c74ab4cffcc56767e461887a940ab3a2a6cd660778a07c9b7cfe8745b50e3f4676cef049122e92e50f6c6e6bb27d70ac37ba3caf0d55fdcfae3de0f12a14ca54e43ac58791dff3c2300fbdc9f13d41c5be63b43b15952a0d5aa192e5175b49f83c629a0958d5c4dc0c8e1a53a21e0ee77ad5dad1bda1566833d614222fefe54c7f5fcfcf4c37b5d66285576f7a4a076ce23d0c5343037b1de78c51bf37d0c85f05ebd042cda4e9373310d78555c2634c3081a5607b2b719420efbe5d94fdad03b554b3169506006aa5a201e234fbc18", + "72d9dd9e5128bba91b1c09bf62b916129684f47bc1452ea964129ae5b42c42e40a1a15250e7ee3fc0e30e1568eb38d8ddae062e9ec595e1d91f18896feae68f5d15f16a9372015a4524b23dd6a44df2b9e5e7f789e86b35cf749c44aa92f6f6d821228467137515d40a057c50dc36e66f0e9524de0f95886d25bd138f51ec9e33778e29a1f2f0eff3c0beece75c0001ff6b30f9886c3f2b75514e3ebed9d9a9492c33524956283121ed9cfc2510cb2780f13a5be78f3c63790c5901cf29e16f927043467af26a8e608b686c198f6558b28f82900ab3c6b1294001a402611a2e33d196db8fd13caba0c2e6ca074de872c3571a3b3d3b538267aee68757a4f320a", + "4ee11f624252cf962c49dfe998a043b58d2db0980b5a0a7dab60ae0aaa9d007c6a8a9661a352c2cb6a169e1eca7071c7c5dde771c57d542341d5d1a378fe7622085f5acccbf75c7f9ad31fe108fe476471e49867b727732cfdc126656858b3ac35a3ee4c615794a9b6ed59617501bb3860c92b94e1c811fb5299e1e1b0a79a1ec8484cc80239a82a9145707f987ddef75d3c227dfe9b3cb70695a01bdcaa47bc5a67cc96847198e7dacf8a5d02873348f59606dab9d249077b67f490282c1a56292440374b520f9c8e63051c8773ced2eac706b0133df48bb1df6f63e76b7d12d1a0f50a162583717863cfdf392a17a34baa04c27ab909d84815f20eaadca35a", + "119a6e85e782a673ed98e89183888631a2547e889e3f9a2768bc98af92b757b01a23e805d3ed5ce20358fb7aec86e674aecb32ea5266d5115bc2f1c407afeaf9e66b82147ddcc885f0defcb427d1ff8ca5b28e031f5d4d19621d8811b6c606e688798a0b283dffd0b336d51eb3e8cd938b786a8526a286d7f3f9c04bb188bab6313114422dd32f31d328a776ef657f0f954b51596e1f3ecb6e698286f24a8ce986d7192abf458224912d751e7525998a0c08f63d36ca39792ff05ee278a4916edb55ea3adb3b867de5c55ef1a25cf0d6790ae5fa022b6bf5091d15bc2a5308672ae80501a05027267d9abac981edb9cf7842fec921ddf355812f03302150f05e", + "9d99648e6c0bcde745cea841c442e0ec9216bc98154dca3fd3cc1ffdd2100d3fc5701c3b84aaef2bfd020c43f20e0280bad7851589fca7b3b52b46cff1b49602ec15f752776efd3057261ed00a030a9e7ef7b5fb33742c8b7ad1f57b41a17dad206a79d071b4e82f93d4fc787abc93d6c2f25dfbd6de802f28099eba5df8f0da827932366a2cb48716d84a73e624356c13608435bcff50a27d628f65e8a913f558c9b0f529f6a168aa0f23d56b082d1682d0ce9ba63d3a89b0a920f6e9c89c2eae028f4fc06147beec5970c420d31c36ff1e009f95cb9a6814a26b2395821171903376d51c28d1dbfa2af848346d0b303229e56b5a99608e9681b74e80835dec", + "1716029ec5a7a66d0fdf2ce6c8caa7dd08ac4dbe9c3ec2c8f538d61cc7469c0e01197270c5ef35dde7aada83082cc6fec8eed6217e5a05b8f77578554617abe18d5b42b383a470db166af5c1a33a4d7ded88a687d4e76164d8e23c9a3c2e8588105bcd5097eb58a332c45d8251040b8454b1d8a077ed27781ecf516f41471a0d35d3d020c3a6db5c4409a178bf478542ac12597c5468d8a139860fb6289fc12af9aa124d7f218cebe4655e7c7ab0a8b2da68368e91b2da8e06029924244589e76576d2aeec261b746ede2a8353ed07673f62177267666bbfc0b8d00fedc8206745106aa50896c73c172131d9df503dce639a84363abd7a1b0a2f8a3d4c2149b7", + "22d432c67f0b77a9a535fffec70b531cf13aff880318064c926c59798ea7b732e43c63e3346eff13aff43b17c9cce6383aaaa3b75bed99eafcddc472a4431495e501a1f12ae1f26f92e87c7409bf7242f2393a5869a5d398495bbe836de3c202f92f59864a2cc9d241430a8eea15128b470a0ca592e6dce6896066b21b21f1db1882cc56aa32d19b9a5dacba81112eb0c908d77d80c8463c8127b57f885a5759fc6c873f97cb96da5f4cc4952153511ecd3fd9509494a773501634b00df09bde3bc8f88193a72b2988cdfedf2921774eacf5199b677e926b5a4ff2b62bda1c4895083beaf250232c0a0ab4bd53df47379049f70f0d38dfec100346bcb516185d", + "2236d855d6544f7b738707b0567de0ee1a168463af3f345240ad802ce55d43e58ce2689928d706e34facc7ba66c2887fa471a08e11345bf53d4b42be5926d659a0d7e8a82947d6b735643e940ff0ac000098c66acb71560704846baf37eb4aadaf50d3546539371a969aa1783905f0e2e81af787a1218c5b61867af77bc0e2ed9c24fe343f9d367d5538348d3b6936647c7d4e3fad3f9b7684ca79a8b97a7772c33d66f76301fdacdfd7a7df335a25a1d4a0486ec30940932a6db168387f0e89bf3f74129ec480f3802e5e28486a568f492302cbf2eaa839ef4a3f43ee5940511e97261ca65abbf2539148c9389ca131037320f081de931ac8aa3a1fdc8b1c5a", + "29f9acb17d2b78fe398a013cbf9e5132b57e475d41aea9e6259a2ed4075ba089a66473c7140e7ac45508c8034f76ccc93794c6d37eb7a9f3563d9af418668be43ef05cbee136d28a510e47ce8e77d8952f4ad2fa7621d9d13aa392b41eedb63d24e0aa990f4041d11a680655725f70975a5688291218f870ce4aaf3f7d89312facbe2babf446bf7aad496fd5610deeba8f0c003f9a2a8e8aecfe71cd966fe7c6a403227eff4d6c7348809978ff291802d4036c1e1646b91a19d011e294bda1eb49944f62d462c680c721c28e32cc5d4fca3f9d5c412b09e102b9e4e8bb69dafd97ccb51cb1258ba2a1f2e9ffc27e98361a687bb505a8a238cc40ee65132a4ac4", + "9c75bdf68fa76abe313a52ed02309de35dc4c11035e77ced1c9d8de2818a4efa1a64bd4733de0027c52a89cec682cfd95b8ca80ad27b6cbbe5d52108897d276cc725eba7f1447f5e319e098da8ce75a27d9d2d239611d3e472a8a7917821bb16592aa709ff004896d2b3b487062336a0650c297d61ae15fdbf21fb293468e69bf9dfdb4de014f22677f8b8ecef4102172a6b21162535a20d43034c8c623c55537f3303a09eb8859c24a802cf904a7ba7f20256d3d4110302da6eaa147a6ae46d5a4a4baae8a5950b4ecba40fbe11cdf071426eb431ccc14b249ec0ed1221ccd3907952716b65fa6ab2a3bde875c8969521ef275f6d138b0f17809cb80c030b68", + "801fc2a4141b50655dd1499c01d23d733c401d799d465f9e1df68417f7dd4f2d2de80deb2869804304678bda3b066ceb9125abc1ec3a289d59ef0933950709cf4192e8f8952e830fa52fff8840272b0c19a3bdde976141e86aa5f1c80e175084b2864bf19c49aceb322b7f47f3226193b4eee5160841fb165e1c84edd523cc093d986e395cfade6214a770d8079b7714d36afe85381cc8f516013265b68287f148ecfcc42ce4d153029fb57716183e39b96adbbfeea8a7f99dba6dc8c13635e9f4cf9632f2f06fdebe9adecd6f103f15e08fe1f206965efbe385f6089072555eb9427df145032cb89b99143304bbddea00affe41a110b862a6667070356e8a7c", + "673d41341e53dfacfdcc7632010c4160215a3345fcbdd53b55ac32bd099f5c4da069fcc72c636c4fed1b686a074c1fcf60eb760431435c1662eae289975897d76d272b4f553a9b461cf0d36400778829e54f59ef2528557b4bce09b08e7e3812e388844604ece012b32a12cc1bb33decd8c41ce9adc8c1348eeb5c83294d813e5396f37324ca7110a7b1c17d2bbe6344c2b8e5487fdb91d8ec31de7256e6269204ac1ea48964238d4592ed794de6492805fa925b014c706968c18f3f4f6276eece08d21b3371727ded7caa05e414220635ce67af0dff68c7f0e2187150367f0396f81213e7fa07656a88f5d9e8a6675c9bfcab4458d5250363ad4c0d0e50e982", + "538fa43aaa4d7471a573df452fcf632e984f91fd98f7224ba1040503144a93124bbaa7df32d4cc9a66dab20c0f82d85c244d8194cc40695bd6b79f24ec9a703f98d121635501d75d719d872a6fb92a8bd3c17d7731dd101cec8e9766a509d228f045b0fcf775ad1f0670869ecfd7709280573db2459312ca47284d4b96b380a4af08e65111c461a555721a48799f0c5955ecb932735df8211717deaa541fb589e1bce1a6a39248d0d352a6fea4805ec00ff140607419c9624fe4881d69f14d5cabee416618164ea4bbd86f3d9e2b56d9c3fd993a923ddae8d8be690f7b45d7bdbabc31c27bfe5eaed1af1371ffc3042d7777301a9e493ffa61ae59c79085008b", + "9197f3f1fe0f0a65e995ea840819d7bda6f33d19c0f022368fe1ee812556541850b7c79aad95fad95525c88b11f5369e8a2732d0b85cede230a8d036b55c2d94c484358fe8bb5ab068a10cf6af8be656b9eb995abd586d3607dc33dae00fb9b46e06b8b1adebd5704bae2a43c000bf9324a239de38317412cb32546a69eb31d9192a8ec54c8f8255a15d8dfbccc6888ba0c44b5e5e1dc034c273c8859ecd2b1ab57e0a1d66ae054da1bd4dcdff395fb7b4787e540a1f7017aff60ea67f88dbd453fa47778869aaf6928b48fa55b957f2f040d124875a7baa9560795b594e4af268eb6e9510538524872763896ec9409c40eb680aa479794fd4d6ebaa8f9eeb", + "7909d038aa9d70da103f518923c518b56401dbee7842ae82286da67ae3659e56326c7e994098f2e2dd2b20f0886cb918758aeb08c9e303266de1095d7e894172b1a9465fe1eed1ac3b22a8bc4f38185dfd3f3f7a1963bfcca475495dcf854fa991d9e591c870b0337454d6f33b8b3ad963e131d3faa9e997faa3888890f89be885133bb614fd3bd7b66f1ff493f65008afa1f53e42746a731cf99e210ba8440c9dd0be6a2286e90a743a9ef54dfa63479260c36b9e5441f849597b15f67533c90194aece05a388bafc4ab24b076ccd84668a43b551d5de0c9915a362b97edcac28a7f283c326088c314a1153d422d735f948b67f2b387acb3e22dccfa1f2b861", + "3026c4e297a2ee444124e22a1d9fd40d012648dd9243e91d5410645419df1d5817de7a6919dc46793a4c176ad109fe806bff1fa42c0375fe8e44e0883d81c29d0d5b457d58c4018a9d3f84d40e7516f523c1e9c3e1c8da4c0b29f17a3e5af73431762bc03a394dba635f8dd0e60d5305d11cd1afd037317ac172093b0a17ce01309f7eb2847f8c49ec2ecd058261a09e4cb0350838138d9ac3e9c297b53a15737d2a82a7417a92d8ad3c18f77075ce02dc62653e7fd6dfafbdd48d7d6b43e70a3e3f86959ff621b0d6515694a992637b89b508689c6f02d74b2b0da2c4d26cff8ec19d4d42672bf1b00efa7316838bdf499b497c71ce8c402cb5d074465e4368", + "81fbd07eac14f9e9f153dcf60f7c9e1a38418c077b9205917ca823d9591e0c188c7cd803f16549e9c39eb1850506977558a5ad957935704b159732c3d547fa58a1ee6442a1d40eff5bcf6c30f1a87b91caf17f3bde48749567d5de93a86c8e551125eece199816cf16339360267d83ddf420e118ae649761973eb0110610af1cd2a971369bf4058eb74a17f83bfb28147d28b0ef0e83f3f4d73538e4021d4aa6b7cb5376115001040eea852ba8cd53530fd4cc886cd4ef01accca2d2684584d36df259d67944b4237200bd8486f47da4d6290455d16586e48fadfc73a371ce684fad640b93eaa98c490a50b7d3dbc94ea5effbd4fa284ec9cd0cf04cdc3eb669", + "833390c217117855d0759781f7f11aa3565810582efb6ef286bf6788dad2e45c6ea68168028cdeb75bbd21e8b0d419a6df44ea14fabbbd5fec8c7ae84abe4d15fb2ec148956c43afd739d55c91fc754727c4a295eafe74a222dafecf24d61800353e5499f46b4b78c42cc0b5814e54fa9d2fda1815ed68b57911d07f6e02fbe4cd4a82de2e0f565b1f7d663786829613f7ed14b545d6a34af073e5b8804a170ece3356c1e6631a3558f22765c7a88b37943a60aab45245e1e69099efbf9aa3e24c164302cbab87d3af166904e2bfea0956fb4400e2f486be31089a68bae5890f271996aca29c4c61d2d8df5aa32776cf0861e146bc1a50dd9b37db37b2bf6768", + "166d9b02bc8065fee8846ff3832d29e5df646bfe9c70f1b5db6ba86217562cd4cd7404fe53548e53c4cb7f74f524caba6f30b94fb18b1538f6086fd0b76e256805a258b80b4a24c9a6e2c21912ff57ff49df19637c5d43c3c6d63a1be7e55b32691ac3abc8beb713c28cb241334b9d9abd5aa04ce1e02b7bfcfb514c3c27556bd1c4b87bfdc263886dbcb628001730a9001ebece876f5ace1f7aab34118451112da18ab3f47e8bd4c230d56f151c30d7ff7de81f32d7b1740619f8ae03dc4d841e3cea99dba1601600220ec3ed0fd76249a8a6f89e2b47f9cd51a062db2df5a1b50e837cb74f5d65c28be33718ee959a289a09b94d25f00923f7a41377ebe404", + "5fdd77449e69382c324ab7489f683872dbf74754b9a7bfd2ead94304d763dc0311f35e620e43897b4423b7acdf8ef2d6ec1af73ff6cf39c047e597d3c2c8ba021924b9d90edcf28b17ee0d3e4364c70f0d1e4302e886b5bea60ea90e0426888ca030cdf9741c1312c5074b3d39d608b24da327ac6054dd1bab03c5e55a02c642a5cb1f3b7a63f1edb7069ca545bd75daf46ac958feced71ae0e19f21e50b681dc1f9948c12036fe1ad5529e5dff29fa3a9829cbe0778a3bb86b0e19751bb66b84c5d9dbea1daf9d2a5204fd4d99653f064993fa7adb26c947725331c78a4f178bcf95b8d563835c738197f39de946530bcd108eee59a45f72b14c66e5dc92fda", + "372dbc5a2108fcae254deb03b260005e5ee3d46fb1269b72afe80af6c6805e6d081f6c3646cec6f15a2d89b30cdbc4d870a626c7946f96c62c3a0990c97e31d6488d2792902884fbfd98d372069a57b94227cbf289e4fdafb8b41718c4ffee06214f18fd23cf28d2055ff07e316cbc5c6f41abdfbd39d4649975d105f74af0784f8ca8bd44dd86b6dea6c21676784a4145b178b6ff0e855d2df9e2abb0d997a6b04518cefb85474a193ef5c7a3f2e8cf911482f27ec9e706cee784a753101d0604274157a40de2e0e3ca9ba7c65fb427dd1a635b19dce6c4b6e0b30b8ebadbabaecdd1c2b9639b78deed3986e0b264f8448e071eb1015bcff8cd02b732dc672", + "4f31a337f137a4e4f996c208110d79e0d3c8a41813abe3f6e647086f7d88175e3e4d0805ee1c839575ca1bb3988b31211863e689dc3e321f10ffe58931a8e506229f29d4e6089b015b00b4dc800c3ad0619cda933e552524447f61ca4e36192307b96a9564f7e3024bfa68c983c3d253e7802ac9ebf7704637a39dacddf23f9c4bb5496be9ceac1f44dd7e434b67f3781ec57248993b8b217f97773f244c9d20b71d569921f7406178005f17c72199a29c4759ad7ad1db2a67a6aedb2109ed80af493b25b013e2999fd91d7a8c34b6c460ab4640fbca1e1c449ddcb729608507abbb4521f9d4980d4adc754a222c174a805b842dbd5acebd691b0fcdc81c305", + "1ec2026b9b18ad1436afe93e00431161b1b674486ff45e685804c6f93329f3a910437b15bf2d813e00952c82a2a73271997708132d97d3d6c35fbea3cf5d6efeedf0f06ff298b20946ffa7f2daa013e27c5706d755826a133060eb37bec73b9ad05e7e671216f5f68616d201a765fa1b5d76703d13e9ca14a2fde29016848151ab06336709bd5ba39d0c73fd5232cc3390a2b81033c4064c870e6d85cf7d228ab367b32955cef7842bae66f29b1dff58b142f05b9cd08a55f38ed63936a037b3cb50f935842b3146161a17c89b45ea65d6de266cfd4580899fa38700d8323f0e58b7247d990904a7b78dfdb4f0b1d689f160c16d479d41293e993dabb46d04d1", + "277ee225cba0cf47dfb290fcd13d4e8a4934a48ef3bbf7c4f7c970514754496a8b58a19fd0c59e50731a1096aebe009424150499667ecee67ad9c9f5bd01eb0f557ac2d8e4adeea2231c1317331a030956c65c57691cd831f13b49657e9d2c6184a367691d3d784ea4ee1fff9ef4153476770a7bf4220daca7a37c93d0888f4aa626ef260b0823999e382c643659000803da4ce565a8cfcbfab4d74d05dcab3fefb9863b6fccbe437b566461f9d045202193588b38252588b296600bee5739c421bce5d609e9030306c0ea7a23b383bf8299a9e356b91932b28224fc02e678021d990f6cfb3a327704bcd3e187e5d883a3760cc0ffbc73933031b72669e9507c", + "237bf00e70e36ec3c715d209b7f8bb9ed90b28b195345ff38e964b143113908c77b23e3ab5ebca926487db52c963ce66c0e8bc5c636a5a7cf702b5fe9e5f81b7ccde039a1a01e0bb614f0dddeb0277c362c6044250c7195cf5b9628e2b8761cd65668c437b1a791f45bf50befd94e64637899dc19113a925e995c925ac2d445f9bef5ecbbc7772740df2474a0ead0454bf9a006eacc11ccb4dd1dbf7fa008aa9b30a329523be7ced17ba035401414659335249585ed2570bcb8ca3a38726ecc866e2b47d42c3f41acdf29cf7cfa3b99883126005d0dc904b7c668d509a825f7af4c0346ba22c551c5b2ed4852b306e7bea043c7a0dd705ad6872bfc22a436a90", + "2227426dc518f7f204db80f99cd666db5d31c1c5da03aef00a5e7072902f85a7fb7f30aa92dcd689514f7491cc97918627356c18d63b93d8e67b36d99b55c0fe4fe9c9ca5f3fdd1fac6427f18d4a6962b07d6beccdb0f6eec39aa2262ebab20e595e162a4fca61422ff3bc176f659573ca49b359aa7928fe91e6eea3f626514cc4e89e88f142c97f6b1a2b4420a04afc0dee4fe204dc8b5121fc37f26f5d0da94fa9d575d68676b23ee7b13e13a01a85d900a74d81eecd510b804e5eb325b17d4e3cf50de7b5b3e7a346823dcb988c66d723ff8a7d72cea58d25d6b7967d1e7ba8b4756ee2b1b36dc515cee5cce22fc10d6a8ac8db212fd40ca174605999b6d", + "4de1512966a7eae43b2e6af315d16bdf07dbc1021e343aef48994d14436a83a102e1bc8aa211db804af6d40f2e3d9e1891354bf99d972ac4306c7a9b312ab07a2ed8f41c98fe213576d754a7c06c980e5b940603376f91db07b88cb2a83ea596e50d51935b18a61680d0e4f74f54ee6c48f999a2e44c7b8435f88db47b32666b33d75cea3d87a86c04f617eb5066c82caa4dc60819e6e2e0ddb8da2c53ed6816be7da12ef662786cbbef8dd534ae8267017865b5debf44aadc28a2bd817f7b77585a7f2fcceaa2bde7eed8548d3f42daf86b590d4b675e34e772d76ddce267b90795c1bcef677db196f147a84d5646f8533170cdb00fdd50a980159cbcb92b4", + "2857ba3c94c7991117abcbb0f8282dd0e1cab596f4bb5501622e50f6e68e70112ee1505ba31370a3b337baf7f126a6eab65b39661af9cb44680cb17069e20e62796aa117ffe6ac8d965f566a936373239d516b0cd93110e8df1f1f8f7ca311ab19abba54bec1a6bc85e7b4fab4ea8370a2dca316f9994f841b5c27bd2b9f199de6ec7dd011e522454530a7a7729977db993c4115b726a002c2dfeb84221d638409343adc026ea4289a5fc23e35ce86b7bdc576879cbc631067aff7f6420c1927c77c3f42a722c5593b851170ed2482144ec8cf29c8d3af95b2cb89fa41cd2458aed846e44f242642006601fbecd81e159b51142a5c186c1d9ba83bbecc97c887", + "38a6cad8e283af68c122caa121e4ae907f381b993966f2b4e150882b9099264bc648c4e813611c1cd63d4beddf9cfa0c07919265340bd327b36c37f6c182815019f746235b858840b85c77575e158048ea12c93949afa3a9b34f847354e0cde1844122e23f989d9fb6e76c1fcb720fac7ebcf9ba54c9dc5f72a21058d5d8b6967bc152d276615a7ffef205a7ffc53d08b45734b1af3cb2a227a250e35d6fedef5f5a90dcb2f52d189f95199df410e335bfbf7e9e16bad8af8a30341274acde92757feb7edd0b6231300ecd94082c313108c5389e81811bc37c505323a9c787948e44e7fd05fbcdf2754968faae9a3c5aed371407dbdc0016f6e8b2569d18d4f3", + "974201af9a4c39b588b73d89b2e27956e3ce936dfb60f9ea44a468ddd5f7a50b6b8c5cd4ef2564cac693dcd9d49e56ad6bdf44b1ff761f3f8c7576ff6d922374cdda8ab0691bf6319dd64670e574e9be8a58f58c32de8ad8ca054e6567a7895f713c9a45af4b54c8e48bcf8d5c2d56dad56d9f4e104d9da8ce09097cb946f486a4217644bc02cdcd0da6e513a5b0bef9f3546f04c6f287502aaf4f3fe39e5d6f659c75572fe31be126472ff60c9bc211d22b1f639c87524497ff9202ef42a9ad9dd912fa1f16eff1999f71116f5ef891c7f5520e1fadb5f3895edba5a3d46324e0e2fafaa2c517c62e0dbe6f935809dc496aced4207547ce8193f598d6c39dd7", + "27d37a627c3995a4bc99df95c5892167426b3e504cd702fada01904eefe0e9cd25af4dc9fce201dac599eb400b9333adcf47ac46a58356c7c05e7c8f7465f345923e59125e0587f1ee428d18b2baacb0453e2b1096a992ccc3aabe8b3c53cdcc4f10c381fe9b8917ef321d36962f368f40b0230c77cb46ec2dc68da2468c83e405ba5e3260c7dd4989806f540d992ac3c780b5dcd6f931f035adc763c4e7b127e9f69e25adc271f9bd5c057a0796ae4fde77824d9f829763d092a331505ace227583a4bcee8fffde242cee4aba729144b4495643531d36e4dc9f52bab15850e2ce044052337526e907d8236d1566b66daa963d355f8883f15a5bdbdb3d0dad0f", + "2dde56f26aa5952a529aaec3608e425dc55aee929718694a3a9084873ec996100b4ca44b9726bc94baf27159162052aae933e7fdb428ac3c3cf06210188786ae11f44584ffadfdc360708917d27dfb0a8bc61658d8a16817f3a5faf6eb45cdb2f75c2904f2328e876ba3b1bbca5b630da3e69f3ab081c2dffcd30e1158cb6e3b2ff378d522d731685a8e8cf4fb63929c8ee0bfe599d9f3097ce93bf8bdfc7920171b987b9573e3833d59633c72dab59b3f019d15cff6346fa9ade6216fbbb3db55d28c8425c29ac498107dfcb62e897e35ea7c6e30f7cd5b7c961b80a7f7c57afa6e909b183e9a5df5ced2af6271e4af5fd79f690fbf90da2ed41345502f3e09", + "5025447341ff279a325976a1eb535f5ade8b954d4a6c06e4c061d0db92dee5d6b5430e452a8ae80f3bad41dd8aeb0c6665c3a13976a094c278db649d7de040c10fdef2b165201f03f7ae772c29cc01ead833cad9f622af30a3069a60df33af1aa9bbec54e590ae0c9fc889839101106851a8d1fece068a938b8df4e824f365116c0507ad1cf4bb52aac6c6345c8503186c886444e78b6ccec46662b020b1fa48c8ad48f92398edff5e0f9b954423a0fc55095c6df26ed540a31f4eeb8d3626957df829ec935f1b89f1e6e9e05f1fd84cd57520b123df0d0b6e15e11227038563a3d8d421c703a1f9b6be1b05ac35e534bd7a9ebb8a2f4a8f52b6e1217c8e45b0", + "1a7ad94b1a576df9b25e486412e0fe5b15a1c624bdb07c2db7d9ec35d29b7f66cf5082123d6ae1b0c6ecdd3c7d86f28249e470beb96c44ce3f20de8a160339b02aed522428c372fedb7efe57fcee1524e233b1492d472e2d68da39917e1d207f0c297b1b69edd7f1b015bb2b76ed51ece80e208f07b485370c39cd1a4e0e8257aa4487bacf9d1f1ad6a3d02942c5e9894ad98b13820bf272c4a122f6f17fb7cfe9c41148b23e57a9036937739448d8a42a3395f7727670759aa220de65ad9c0d2fae7c06ffd4023c5bac7429e0960af0adf7cf67c24977cdf725a8bdf96798711981d84c91232fd9cef46f565ed8b6e3c26e07a8128ecc06c62f6125d52ab7b4", + "68135ecaf4782847560815e0c9b6b9e250a7c26444415a264bde8b333fb2b4f8805b4e7662251bb99949e661ffd289917e87d2ad6d4b9bd5595762c665c7ef455a1098a866931fc4e6eceb0fd8e3d21d7838c87ba4dccc3decc747ebd9b4e7be30999617235940e5d35711c80b228542680ccf59d637d3c9a6711c3dd2330a80b1845df3bbb0aed3dbda48de0fee361a636474bcec0452b27167cf2db5f789ae9e9f1f39e47cef89e13b0a4c798838c1537d3f05a7fb8c865b144bfaca4176defcf8646cf6ed29cd987f4bc8064a881b0893bb2b6cf52c0e7f8227cd4e79f5af0f3937dc87bed7abb360ff0fabc18bd73ad4a4dcf019be5845c785e1e5c57f6a", + "9e75763dd70ff7719f7404e192c196587273a404627df91cfad9feefb7110d1320571b84ceb9ce9658df1dd32ee934e34a3e08f7005437176cb2c3b6bb83101cb0305a00e23cb8f3c8e4322c083d584ba2ee81dfd783669228008062a73a63fa71defce3f6348d7aa1068baf8c1880b84d02425c628fbb92aed178fb4ef9dbc8d3d7c0c5ba74ac6f0c2cd85bc5981843268df21dac290f95221a9ba86c30f705b81d174790a45739514916a3f83a54ef0c488fb5fe3e8fe14353f69c1bf75a1e0284971a965ae03bea6ffa7a58fb567ca29e6024929da935b2c172f463e1802008a6a63269367b15396d9343875b0eb4e9ff077a1af4cc2502d8046b785e8c32", + "a4c53c9405dff8ee7e565084212cb7419d311f121bef8a44e163f22a45970dec0b6cd190f991fd9011bc708627c7e9112f034d38b9dcdde058f0c28351f6a53a29c01cf1cf52719ba79e0c9ccf09c6edb087f86af4bf891cc6d8e025a4509b2d92dc45d7f575dbba568c5fcc3470d4d0378b11ddd4d84fd87746e69945f8fecfe7c293d28dd904410b9e1e3b339ead241143db36957685ef618acfab0cc81b71a100fa82bc0222b52a4048f7c54f56d5d51d1cd1bf0a29a6405727e730be0c15bdfb5543ac984fa564b0f4019bff1fc6cb87e198a7112474783956609d93865b3a9ad0b04d4005ea647bab0a127f59cc4fcb3b5e9c835671062ff3718109059c", + "6d736e10bb5008f8bf4b39d1f4b3594940dff6e4afec74ef88b9475b6b3676d85b9852d91af6b2db75f3ecfc98a392697610128e0bed2a60b579a04e8b197aafa0b9ea281e4b48726a47aebf66043ad9c5487c0459329516af7493ad4b31e01a87ce92130eb111d7d6dd97af592f606e64746fd6887d6797d48324fe496c0daf3c6eed6725c0f3a07fd44d9fb767084607d3ee3a046645140b683c7622c528e11070256295b62ab29d4bc45e80f0911fb3168fceaff556c603ce78ae1c906bcb5a1634046c464609541e930036921bf4ae7d8803d0bd0837a718db82915811b9af780682dc0cec55cbe8389f98f9f87c0df09da329b33a08ac7f730735b2b229", + "46f255ba3f45c00b773117f839c399351b5f0fb5bf3d218d7550e6e11ea9d998c3192d4f745580f52c07d7dc53de13294e099f9f82f1bca5eccf022cee287675057d7735bc6d6c62931ab998968a4a20cbcc89b45a8a6eab0231fc73afbfe095b6a304acb5104e4c5ada398fd683406e6dc8266c414b1bd62bfd77108eed5601f7145646a3fb23b454571c4815290c1ca8bdd8468ac5a0cde1f0606fe1478d32b4a1b15a3b6b1e08de0dcab0680be27a762263a7641b8457e83385a8a95e2ed37fe9877530db3f906506a75a3116bda3fd914ba2bb520b57239d1ba906fd3f76ddd7ec96b766e3fed96204d95b044a8beef84d4f734cdd0b07bccdcbdb0d154", + "3a68434d2ba9b9b6811fce8ff5e47a06505f2b0e85ffb408a897af2c1ba36743b58abbe0bf3d67e62566292f91164dda9bd7bfec072d0df6e60ea2c45efab3b8d5dde1c2a2787aa39ee7c341c24634caf0d31f5549848548d71a16db6a745c13b2256804cb52f6a8513714b19ea846f831085b596afc696d7c4b022b38fdd38c3b3862b83830999da727174609ffe1447818621b93dc9cf729cbd89d0a164055007d31015c96f62a33884fca7655d53898e5826bef2f55e59c823baedc83761b9b343b3cf70d033f92f075a19fa2b8c8750db8d415b60942caac1b00259b9262b89d336009f401489a70b2f582cf877fe37ed8f26d1ce4345f1993f602c2aced", + "5a27794cdda63c6015307d827f405dbb74fd70ead8658b5600c5cea4705ea84201a5e06ac1de838078f522bb0f6f5b2616d569a9b13cb6ff382558b1886be6f56efedd0fa5137c4295690627ddd98062ac9dc8fdaf100968f770dc90a84aa0a269c8be0c1c63595bea31364c6b676e6783e2315eb4a7ff29d1a0aed6aaf940843b812abb27cf379e556fea3bf453944a888c9cdce411975a128f55439494263191c6f64350c42075ccc06b25519057299171329921d697cca359e5f102043be4dd9329880dc7f85bb4f77367c1a8e20cea242ceb20340b92c607d64414651b3ae1980ecc9c6918d71f8da75ebdcfd2d199791928887f23e390534c92495eae5f", + "652813b8d5a6e9807a8c72934a4dceae287d02b84c8dfe2100251e16f3f15df7c5e67f1b4d410364f800bf760f2f4766a6b120042b2610eb128ab2d724f82ffb401eb7406345e79332f16f4f849755fa50c86b21fb12528f553d7e8b21926b008e920eca2ffba58891802415267bd99c494e88aa8d88e6cfcbf92d3b0d8705bd4ba44ce18d9d684a6736cbb58883a950961f99974bad7822dc866497f126d38e4f00bfa9d046ba263d29c8d79c33a2099e9bd8c814e06414c9fea23f67d24eb15af35d93e881e9287634c90ed77865c8fde87a7b36e47399d4badde8f243dfa3d054573e1c71f6cd081c57ab0a8b8b08a4fb21724a2848e2781f3158159bc328", + "696f1145f82b9032d1d61cff160561b9b96947b2cb6badc7374b32f1a990d7c19af9ac6b70fef109a42965bbb9d0218591cec81e67a497e980009abb382ddb5213e076a22d20e4cce86415a0ff8da46a67c98ca5fbab1e13273e32ae67a99d344b480e03a8a0b6a06621bbe663b0e8b2af7d8ac99bed6d040578d42534c1b66ae074d42cfcb43f1899bd596b594f822c12b6d4bd0a510ecbc15e2765e4e0dc84f56e9ad91fd24371fe01e530bb6dac93f4d5930a8938232e57d7da9595dec5ffd1eb3bad9b57b108694f109dbb6a8cecc957f95bad29967b294bd2de0e095380cf035c98c09f1a8d1eefa5d5cf79e8d35e6d656d493e30dcbdd536311a475588", + "6e41b6beeee42d205d1c3733fab36038b495a992505818a331882318f18338af2fb6414d2d6a2fd34bbf0dcb678e72bdfc73af0639a714748ca8600113e9aff25fc37f90ea3db80094974a43edb89ef8ea7d8ba70a16ea690e2f56bb7eec3a9eb965d21cf6269ccd33a1ad4f1c56a5998ed187ac65fb7505b2f955256701501f1188fdd1197c53efe7b71f7ceb970b52cebe8a6c8ffcd8af20e681ce6cb68524bde81ee08e340384583d377d17ea68bd29b0f5f61d6bec83601c8323129a483c98c63d364f68985197d3015219aef3ae9fe984003babb77a45d92423ff0dd5813764c56b8817f004722d653177dabafd9859e6d38b69e889f214520dcb1a7ff3", + "227342d2a4c62370aeffd3b6d6e0ccdc19f0cba921d375bda028e9af2166e028d08f2bc706d4c1942e1a4e439cfe3315a6be8eeae8c78319c782a6951d7cfa943cbe4e6ecb7a8dd87af9749852c05626c18ee5e083d6299c236bf769c34e1fb5de00022a65d8d686017d64d844bc0e5ede0d9d5b6bb280d5c9f1eb0d2e46960e8b40dea17f789b03828155e0195aa30acaa0df248f06a6a9726edeb24281f0df4213cd708a3e911920c80794879130342db9138a3288ce5d07ea90073adf8ce95b93e9bdb6b422ff3b3a089470182049af02d45b0d994f3d25146982bf507e3000a0af5e6d7303ca690cd716400a3298f6239612ea570706c5ee5c770a177159", + "a34b063e8dbdf82c9fba9a395ce1b516b5ec44a639a980fe3d73b5602e20414f3dc135e51af0be3be2b1e2560e390e4f559bf6cc0e9cd58bb6e01140dfa0c6385ff3a2242b9147d98671d56333a435847ee8a831530470e170f3dccec43543f178fae4d5e9b0ec60ae9458de98bdf899a22ad86000cdc088c6f3c5a17acb097f98c5280f64954a465b8b0eef930b360c83cb6164cf587d6cc755a80919135b87abdcf890991fcba3ea4f455818c0d03267c12dcaf92035184da9186baf95f5a7553e21aead558d07b6d8fbfecdaf9df00f9773997644cf41f79240dc2ad69e416a921361e6ae0e7832de1183441981eeba32f0a316bed4e76c08388a7da3cf8e", + "7f5ffb1cf6cf6beef9c22373e52a15ddfc146e5fcacde96f0fa91bd8f52d0f07c20b0927f46210d3f9c9d6e8cb62ccdb1213566eec0920154ad653e58c840fba9c7c8c3b7fa2e4813c5c099ccbf99145b7a0eabd8d569ad8efb1bfb73f3cd9c2c363667ecc7aec26a2f41cca22261e33d2d412d4df38dfc28bc11b48ea0b5a6d3b65f50d07aeaccc5a61d51cfd19329cd98d460c6515cccad8ef3db802cbadbb40b7dd44890d8f7c5af7ea365053affd24dad15af96f64e2e7fb16fa9b844fedc02ad4460e24847b6307713cf076f9ab77bf4a78af2b8603f9b00a91c623097c4ca11484bc9c405b9327fea667f661f66c9345b64efa9ad84b3a2871856ba466", + "440ef9b8f816bd14e35a2aeac9973e9f55e0552f40f56cdcf6a8ce468326dcef671f1a2c4fe6fe655ac5a2bc200b1be606e3b34118efe3d1fc190bc44118f341baf226c2e2976bbccb822d9d9e259ee37b25c3c349dad6b2055c85a6d7b8cc9b005623fc35b9a4c9f280cfd1da464e6651c254011c5f03ffa170ec233162225a24a9f48081418ff583021197d52a89ffbbd89eebc5bfca396415ba0fde713520ff6a489a35dac1aa3b5da05d64fb9ce5592263a1ed55114f23b87edf9da9c930c439e002b1819d9ff1b8cb21f3692553c44123d1c74416ee6a018913fe17d5b142b2425895c85dfa1018f7c4531861318ca19bf59adad7c062aa72201b2a6935", + "2cac193797b7ed964cde062f23c8a34600a408eb149abfe6a54693eaecd6acc98ad419b7e8079f47c2c7ff483eecdb44d2c402de11ce793e5c91b84e946516a310512e7fc3d23a691b859396cb038b047e3a0574eb7a691c11b06f5b19bbf75b6ed79bbdcf58d2ae10955ab2b623863865e7c7e08510c3147f5d2a911e118c8334a8d23a309e9a6a0ec69165aa22b939c4f5350922ca3c07ba49a79f58ac824d4c2b220b470162fabfee10f109858fa959e13f3108c3b247a8549b0e35f74b75705bf7665c6ae2b0ef02516466dd775d057c43f15656a9c49eaf24b1246e9bd66d35f1a2e1888d6ea90d56cfc16faa5532cba9b618b740a334b011a394edf61c", + "57da9de353dd382c5cf2f4a23a9c025e97b544b5faf0b37efb3f4e862bda4d6624254a8727264bcbc3125e03360bdbd54b6953054310e7521a35e60261dc61fcdcc9932f33aa6feec9a9cb342cd781565c21ac97c0c8d62e6af9cf07441dca44f7bb0f8fef04ca9c8a056a3fb45902015b25cd5c4ac3ddea1e66d8f01db793bc1c2b8947bdf6ab429f4e6f753bea9119a533ecf541d137b1258278bba979a3c5d2569adccde26341396ccda9a46645d1be24c40305f1cd4ca6c2b01f47ee3187b19d3fc4e9df618a96fa22ff9bf4f87bb69703a3f4d41a8544fa214e0b8ed2e5e5986f86756aad695734ef1cdeb90c0d2c3fb72bc42fd4c32a414dbcdd5f3ab2", + "4c5039a9675f5d063f23001e6f6fb1fa222041f2f55e70ebd378115c4fcae0bab1a78b9e3c0cb78cdcac6d7f6fbe183696a53296aa8c8d9653625037cad7b16e2d6281f7a5f1bd35fb0f0963da13c4fcbe309061d96c4c0fb2f06b2675e9adbb430a531647da58ae0f11a00197383a26766fe0053e4f71ef1f861976b3e87a0744f3b41f396a015fcf88fb719d933879c3f495f8a301b806ad0fc91232bcf4b57ca4d949631c44c78cc7276dfc7af33a14828c2b93cd0c738c3902f9b33c19af10114d1ec345143219add926a675653d9761cc8c2b5a28f2e5ae78f88859e605c32aa1e519c4d86fb558c1a9c74b738182a3d1520d304d2dc1a30abc79c7d92a", + "3c48bc3ae17ec4f3455e025e189e2adfef7b5dbc9f9282d585150c6032d285fc6b793e7cc1a866743d3cfc24a0df88438cef3301631581bce0149e552e2a3225c8b5d725d072ce84e36e4edc793cdf0f0580d303b59276d0c1262797ecb141022b962751408d4c58d0a75af8ac934fb3102fa826a963d18a370c446c626c58ee4020dd0286615318be7da598117c68c63c65ad27e08344453ff035806e31c69758652a8acb8b3cb8ec096b6759056d19183ff4f1f35b86cdeeb15967a30d4fcbe2d2c75648e3805b8c3617e1e97d1b4af4c73ead3fc50b23ef426f55240b916789226d06576b6809d6814a30fd77a83777b9cb0f0ce775feb2c5004d840367d5", + "db91a6a861dd7f127db6350b8d08f86754d8360d486c8928f452265308c4e04a3bbca28d531ac711d2c804ecb2bf893e6c70ab2cf7c217e03798f150b7a4cf856c4599aceb96ac6527e77331db6e4888d700328d3b80874c632dc81770aa800075ee816746f00943e1265ea79c81bbd263bcbb2d773a7b1c6f84e26997dace810a338fa85e56c4c467ae0176b2b626bd027e7a241884f6b71563dcd67696d6731beb73d71e109a12c1042058ffe6452b121406007a565f1eb531cf82ba824b60ad4f68cadef666d74437e98c5d778ce9f2ac6d392d0acb68bae4b1d62805dcd3adcbd2a797b99d06778285f227f1f8fbcad8cb2938ac38142ed9ccdab03377b", + "68ef390808eca2e3c920006901f8daf0662b253c7b354e89091f75277e8d7d59dc95fa12465eaadbe728867ac5beb7f9c1da87c728e0f8afac8621be1252cddc5a20eb3b2c7fdfe14202a1e11f13d23f32954f596f09076807aa7d744c072f4b5ebe8bef492c81e3855630328b610bb0420cff8ca255a84e65db91f3e788093a34de2290caa58e8f89d315b1fdf5207f863e9204356b32a961cef8344f2afc4d921783261fe04b9011d85d29506c08fb4edb1ca26594bd05a21da656b3e5cba40ced118ba8d9cb987054007fd3a0c7652b4d6c5c06c27200bb51f55aa99c336864f5918a700d2bcf560dc1a337caea96c72b061d44fccc39742f8f121490a812", + "35690bb045cf90ad45aa65b59b6dc790fc50970155c4ec1caafe65caa75482c530aa4d8dad388ee61363c4e0f097db5655b1c62af79e5e86cf1682fce3547055330f9bf9675c0f993fcbb3ca498eb3382c7165def5f7cfe85bd3cc4aeb7c908cadf1726f9954ff8c90119f8895d1574bf873214bb74b9fcacd1ca0c0d87d60da88e23ee3d2b74df9df258d38c6e1301f7b5c5035a24e44a2ee74506a730d651b43e808d49f92368acf3032455317ba13ef75419a44ded409cbb438ecc7be09be8c28a14ab5ada8462bcd98a95d99854653bcd0aec239204e4561db79a872ae69d397e3512a22721c49fe44dd56e807b5a9489ffe4be67047b8b5f3eedb5568a6", + "58a456217ffc159219d2ec93110281cbb9157014e53470bcf68153eae95403ac3417705bdb2294e87e88a20c3b2717fa09c5544a732cd93db7d0de67d180633f5648f756c6a77e6b5f591f1071f306d0d634f9d5c09c789b64b4b00cc2d2c76f105f47a08f25e6760475a3fb56dd9d27256858fb2c20148ae6fcd120c3287671daacca5a208dfa739b7922be08697b4b4935c748e8283a644ad8c95f7795be6a5fc0cde928b20410654a4bd4a10f786f4b4773f7c1f1fb285e1250b9194c7109465cfbdf4e3efd8d8218d2f17e11af11388c2ad766dfc5f7e4bba1095ae164cc11d32df7498d7a6b54c1ef9ac5eb60ad02912fe67f814c25b72d614dc1c116", + "5e6d1fd1386354f37b55a82deb6e33f7edad0d22f2f0abfc34adb44c92ae90146f8735bc6c396a3f5425a243a340a68fd34c5e3bbea3f4e5b107d71ca10bd8cf0ed40445a06b1bda289542a0383c4b94c6ae1fda153c125b2619dd38f36a2ed145a781f0e3d3169a0018c2285e99036edcf399c6a9d741bd212bcaca59e56f995137eb2c867b289a6d00cea4a5315c7e49b8d05d7ea2814bcd24f893b1002a8ad7d5ff1cf05a4b0725dd6b977813a1e30697bb85ec43021adb76ab2e596945d1b25314de8c67e070615b65de9df6a63249ca76b7a60360c4059e1cd6877e659dbe5cc052b1199a6d9f11d823d64c4cb04c619e15e27e022a3e75caa353d6fa6", + "94c45afa6d05bbbf7a848b0b1313f05bd4330651454f455e46a3886e422d25409e44a18c2acb3dff0b205e502c772981585ad6966c4a7ae91042ae6edcd914e6afe23be24c68e083ff64df1b059f9f4acca7271a480c472237f854a59302346500604bf1c6d3713243ebaef5eda42ce0572dce21ff0297ba25296239afa961cfa794981aa2de80d8fac01b2293250c0b7a64b924a3d1a8a534087e197116dbad915057d238cce162fe55c428399258294cb958386f148401f7e4ff10ac9eacefe8e176079f620433bdf3d0509e7ac1cb101b00563ca57974bc0e75a06c348de19bc37ae1ca55798b7b08b9a4ebd7e2877af89945813ef8077a9d9d8aab42d970", + "92b0fe5ddc6f695028eb26fbacfaaff5e0c6438ab6593c7c55a7c3a4ce2f37a7b22f15fb28297639a8046a5e0b55d2ed60386fe87796ff1329745e7347ca64f6ab50ecc2020d32eda288e9e1898a72a9c70bc4b539ad3a12d809b38fe733dc275b3490495df24e6e1d5d13d875e36201c9434f88f462472c4b03a5ac20fa5d4239980cc8f014234f14b48ff9c9d1cd9aca4564d13fc419d9e89a0199d6866e11431bc1db107bb4f1455c8c6f19fb86abe1c95885ca3b9531ee49040d4b665aad15888ddfb6addcf60ec40d4cee4df5c8a130e4bae76cc89fc4e259d9b97a6a62e3ec4984d5a356c594d5fb88527d90807ca558a5a39ed0f39ef52eadb7529690", + "5b92448e4bd06d7dc27528e882d1451bd6f4fe91a13f637f89aed012be1ae580322109636ac3956eb95bc2ddfdcc787b50fc93d1ef91d4ea54337c04a4fba1b05103a1c9cbd3d6af61a9398d8aa442406f288e8380b6b2ea18eef144f45920bc96cbf33d2dfccdac8c10521413cdaab7b10519a512ad911d9793468a319e68d93ea88d1e8c6403f944dd3c1d4e8fb0306764cb86204d8fe5de3218873b330706a2dc04dd0e596ff26fd2ddb18ba7b3d6f0531b55cb12f7dae767048e558ff7c3b2a87be5a20a2ba990c3d9223ac5068696449175ad39c87149b5bca535f7eb8324fa6fbb9636b9aa759b8faf455ce4eb882c05f203e5d18620f9334cbd932242", + "4adc309946a5d73c26913fa16a9e10275a5f246a6a8c95bf89f6a28f8992f1e78e8b036a731ab22d84ac5a3b3ff8e4b79603a9cf5f3e17f9d18da42389a4391da63542bf44dd1be12be3dd9aa0fb8e4acae7b81b7bbebd1728b1298fe08c994b79896db026b6013331ad911f34984e1272797d97eedc4e0a697fe6782323767093e370fca0668e1af5892984be2d1334f0efff37cc1dd3fdf57bff01b0a396435ea5812a6521238b9434276536d853b269fa89d8bd05d7d8d76211bb7be1da918920560e5a675ba4f5391151bbc3448330754ffe16201296f8f4c9042547dcf7aace784670f28c1003cc412517c0f60b3487db5268ef94eb235038f02dcdeeb0", + "3c834fd9a3f00ec4a2476486ca198fa2c25cc8285b57c8db5a6a46328408ce610893403ffd4a1138cf342b5f10fd6a3f16a67973b26becc7f1079fa1999e3d212cd4d8c51629704009b58b8ab06e8c35a122ce984eec77b9cb4d00fce0c3ccdf8697ad6b937ef0f7b4f76d3ba8fc51640aead1d63d702053267e363717e956ce657c48dc9d815ac0abf07cfa739c7d4735e3362b98602c7120e91b6859f4f15c35679816e0c7e40ff30c8d3ed901fac6e470b0e7aa7620f6d1d7487a68b3311324483e68d7dbc36a9d353e34429c39f50e25ef7e1c09b91280146fc3a0963079c9c45b3421202182c836889e10bd11dea8e2d8426b31ff7361cc599c0e3d9fa5", + "1e451a474c9030a6dbdbf19c16f9e8bcec17b6103a7709cdb73309b8d0158695fce90129475465e79afb5d428fc746731e1815145ae8e2440a5e5859b48fda8d34a9a7547cfd1555be8c429ffb0ca59361e7bc7e091715fd52afd4de799f8ef785d711d6e1f0ce45832a60a1ae0db13a3ae1bdcd530b83d2dd3d67470918daf85154fe282260728c20f3440da874b77a56212d55ef5fc9f7926929374d79c85cd1a47aa89e77908aea1fed5724d97b6b69110638d158625d3309a9ab62e7ca12a5faf3f20998be8311e452d19219da049cc8df05df7510caa2f74a00b6ab3e5e0c3fc1573fb76b03f99bd82904ca02e86e9eba0155b45456a674ac35709b7415", + "66c384c5c2b4f5cc82faa90d65e59e902a57705a6f8a6e7fe69c633e7c320ce836c461222391262ca7aaf88e86e2147767ffbfbe3576192d8469784658617637f4283d73fe1dd6fd8b2dc1472c7480c2c2d070194312d00192d83904e4bfa87e4db9b187f8f51775ecbc9641af427c161aa980680936581d6e49f4dfe4a7f93bc7fb675f1aa4712eb5956cdd0c71eb12fce63e2a3d7b1fabc665f27394c5a8387e66130d76f9c3a7fb6c6b779940cb98a67b0f8d838143bcfce738e0772ffafc2ed248a23c277c3f06b5281cbaed545ab7efc2c40ec5180cb37e6de1194fd98266c005ff04cbc2e3b0942c7ac5fbb3dbe2bc0017b12056ab193ed9183bbc61cb", + "9afd95c28ca905004647ec175f2266211d9da18f1c6a19c8a9ace20bf94bafaa2cd00cb89c43d5e850bcd560047a510616c97c464ec9c9ad12fb4557f0370114cd484164eef3c53756f4589a6c1493e54a3962771181a583a2b3679e52d24077e47a1751eeda6010bd902e936deef9646c4d02fb131f0ec948bce553e54196769f9dcb1629903f9c23904476ea7fdaca070d0f7ffb5a3fb4d0c5acdda337177e794200e294d647ea10a7a747fcea876842e50115378f22960a80c642b5af7423c6876ddc358bd20b092b681016f672a43bf987ae066d9d4422d8c72814eb34f190bce7a5fd6ecbde9bd5b389df4e1e1ea08eb996a40dd43e5e7163c16397d5b1", + "4ac72558651b86f6636c229fefbad06bbf00412f7980fce208eb3a20a51555cfd9ca253f0413d7a4c798a89dd30f2be611de9b88b65a1f41aa287afd2c62fad97ada73a46dfefc2c64d491c7f4707f33b59b2ceff9821c87d33c408c7862c483fd29a0626fd56eab9953d2ec123b79f6d6377e58a77da2645c3ae30be43ff0ea692e4aded18a67f83a134958bf1fd2f5b75bf24803bb65e347166ab88f2ff80d1541a634df7f91086599a5d9da1f193a10b689145eb5f4a7310744cacd99908a8d334e4bad411c9de1d52cb9e0455b8859a5d44cc30464fbdac2cb62161c660221c97f9593216c85a77c957fd3f72f0a30123929692d2aa4f059d1136fbf898a", + "a765351db0c5ad5d571b2d3192f781f95a4f75a9525fc91c46c613ccbbaa675c6614487e1e790731c0f59c3c20180623d6639f5d376824dc32b39ef343f2abd17a3715c6606b55c04f324a5bc639920e94a2b4a5619bb56647fc6342c5e1e7db9bb0c977f8df056bf61b73cc22acfd563a20037cb69f9aef9532b90d08378e0949a4d503620d04c73db4b597c641ef4c159bc37a31a738b7f99f4779b5a60e3f2c684da911a9709e2ca05806f046bb3a8681dcd58f8c97193c1a39ee99557fe6d756540e69601d581b5a5c3d87e5b8a2de55279c51e6b7f90657b991fc4313f51e971fbe7e5aade09bd5360c0927589a73d50ab490e03cc1b5d61bcaa245ee24", + "15658626048cb246bf2ccbb8527d266cada8d86bb5a211060880917c9794ebcbdf1d364d8294b8f889e1ba6a22bde27b1d330875c835fc5a5cf660581970bfddcc5f6cc36aba6d6c4eb00ef5567e1f2fe4cf3ae1a23dd791549c9286d7b3486e693ef092da1aa7fe7d387325a42b7d6d9d20d96392f3ad038d38ac3b41d4c53e40aa313f474c1248018603fa38e2ff15867ba3dd571b3c0d99ed9b6fc5a99e582e135eae54be925146e5b826ae55a33ea4affb62b075440d0bb532d980005f0086ea5f955a7cd7e681c1bb23d523d798f8573c555463dcc339fc8f60032a5e8cb6bf64019e8b9fa81554b86b8696c2302ff07b0d26bc218c604c6e388358c19b", + "9e2f89a13d58a4aff366974cdd13a489ba2f51fc41208bdc9532bc31d16c0cd737f0a0363b3dded31cde220d81465d076108fceaedd849824be4932f684ba1aa5a1821b76debe4caac76128f7aaa31d8f714f944f1fcf6ebf284a7ea61a0653fdc70508fde4d1d24d78575f03bf18827d63ae0c406024596bd010f96aa0f33facb4f5c4dbaffbfc584e9de64a51e91343cebc66523589d6a882be129cb9e6fc5945f529d6485f7a3343e5ebc3cba4813be41bedac97787a903e3613bf20452db0f6ecc653c5472ef31e51807d2a543238d7db8081c0406990ae0ebe8bf252f8a85e65fd229c5c10ed1a7b1979e47d7c25fc60ba91674cf05c3ffcdc75377c0dd", + "58aa83d1c3c5398018aabfe6862c3fd0990bc729b6dcab36ea499e1cebd741f4b32640935c00b7579eb3509b2999323b72bd25dffa14ba98e76448bcdbfea1438df26b5b346bf9c827c380c022e04327827d20feaee8600e273a0a80cf28a614785adbf93b338f1554489ffce31c3c844377bd376cd393ddd1a2a3bb43e84fd031a7677ce2fc0eb14fac68e736b932af23fdd8450881da357f2d361e17cceba55464062f9398507c77637ecc9f6fe970e6fc5775bff85b492cf510b802f0aabe2c74279bf5492b3d3de20065b4369e8ba159ce827175c0422e4f481295acb0f22a5f6c37ec79a91f4046596dbeb47a220e5acdc4241d19dea66e14c902dc6d46", + "54a4c30b81c9a1ea9478364e59889fdfcd60953fd6bf4b5c1b4b144fb9f8c0148ba3424945a69281ee9786bab5b63a3618c3210bdecc3bd9d448b718fc3a983632e9f349b89b8344bb72f129a62118b77d81a709e1f6cc950b99dd820511049a14d538ce2732becd6c0b81e9b8416d6417176c72882a0ab16cd8bb8147284684f719be64ed514c1ccbb8994c079661e0c970a57e4aa28077d34285353b36abde1773c842f52d34c1dfa38be3629c04329829ddeb8e570423b73336aa596ad7ba644e0abfbe270c0dee7b992fb3c5799edbf4ad2e02ee3374c05f35d3d098ac6b7050c23d8dceb992beffc7e1c1df320f138519b14c42c127fb4ab69d785463d0", + "433bc1401c81f8cb4f5cf33c2bddaf19f7705c5dbd5c9c4ed827d26a8b345aae7c3b75240c7ba5cb84aa999c907bda8779b64413487f21691d41b70dffb45052dedbc9d387f246f7e05d9662a951ef3dbb901f5a6f2ffe573b56272f90a5cdf55ec7ff099355dd3c290181f08370185a13acec2af0c19b706bed29a23264708a61a767a5e9ee4a62d24dfcd844a16a94602039806be0bd4e61f2aaa5e2324aa06fa250edfc2192690ab376601e54c7aaddcccf7c217a50dce08d812663c3109f7a63450bd3e1108072dcd313b6d0423b4c8cea2e16ab6aeb894979ab77b51b08e62d853c004aa9504bd11c4c716f7a6c2a1b482daf0f5c0b6f6ab7849f7539cd", + "9624cb6ada8ad2f3ea39f9d19d689aa42578cbc1dc3677aeff0a444b98152819d7a26e91f1b512c11b90c5032d91669fa45a8025d03b2c048c483c3b9647bd606a6543018de484ffb871473d5d9a231fd4dc21c8fe4b36e7c8be8fe9f1ed8065d331109e53ddf41483e2c48dc64208a5967429882a7ae0c000bf79aa441379e3592d558f4fcb5669dde32945157438395ba4ea72c77fa5a06a95eccde430a13ce3b4eb738af0d9202421f1e62f642ee58debe748f76a0965c528402817da4dae0ece8924aa8ab6e8e94e1895222033ab0fa1770782251d44c206e7f28d3639326e011271988f686645ada05bd9c2cb823516c58867407b8b39daacd5afde24ad", + "6f71d44ee6b5d17b9371d33be37fc1a0376b1e1400adbf835425a730087c74ce9e0c1751b24f2fb97f75874f37bdc228b986800264ebcf6c59aa3d4d625bd6b85d33c18695c2f77e032bb0e64f91ce5ca3fb40e84dbccfda38f3c89f701c00c3c35887bb1c3e3fe7b256daf4591d3926877a12623a3e28fd401474b0e3c0d40952508d73209a9d84bd5df566b1289873f0f1caa391ea2199cca45256ebc420f14a1a8bb0adf6b39fddf73f9ebf4f0c528d7025c8f66fdc412d8dc0db8626149e9397f8506d34932f8bf412742a4f95f752d95a44cadb3fbd7de58859475e8a1e314642dd0594cdce069cb86e2b6ff8d064e5e6deff7c1d1e610e0efedc9a4cf2", + "95b12c6fd8a533342ce82648f24b031cefe9b95f5273f0b37417a15c22c493099dfe416b042cb22bccd8915eb80c34261a88a9accab55cb98809d8d8cd91888a3a9bdf9519722f5ad7e2f735301c418728b7fafdb2319817726ea2a9373543a0bb90d2a0f57ceeeef1014809901073ed03f1763d05804802f05a8b0c1d939733d333e9736af0b0b9f1e0ac7c5b8c90f08855b42fd5e87b213558d45ffb3043232804461d702c3344cd8f62f75ae34f532ecfc2a7abfb6aaa08e3de661ced813495c1e1c68607b6a10e81c330d12a3f31fea3a2b447f4228fd9d9e8f550f97544b2c752b3bf4f7c4831e89ac835e3823e754994395bbe32b797cb9db657456628", + "1fc76eec02e790e4fe9a8374e831fb062727bb939035e5bcefb690779960535c4485a0eecd65cc7bea2bc6070d3279a3d234a8d62796c998aaf15059fdd5c2f13db64ba585b180434af19f00e1ed504d5b27bdb9595bb27f1b9a93e92a4980dacec289230525b001f04185e9af628483c304e17a27349059c8b2724bfe728d95343757ade9321887558528d9826e5192f06f16f0fe3179c9479b4ebee295c6dc61da721f699d6edddef1a736868ceb2cab42e4130237589d705362ff314b877a39028f1f8dd67eac9ae939225d37743b11ea47ae41ed1412129e41f30f925f0f093472b0ae10e397e3f51ace4bece56b048896f525fc6985281f829653b933be", + "85e549c08e008199a9ebc237df1336c054bb43539637e11d09e87cd4296bf85702247d1ea9aaf7ded3230ffcf28f923fbc3f22bb5176f2a8ab862e060216a885d65c8ecad3000dd0a5595a850e53fdb7933b2742415fb71866c4bf5f558f323b38648308cb2a257c35258481c8c74168752432e9eebf0acd6c48f4cf9af9929885988e50f8907f49ab853504cb0ba0567c887953855b2214e8ddcbac22a6154a295b09663b5c76858a9a509769142b423105e8b35306a942dcb45035fd3b727c7ab68285be0f846d1c822dbc50ba6cda4691847484d65672df1e400de5451f86fdca04dd58e03045d0cefb1a7974e7db64d04f96eb372c3bf5d8995398263c0f", + "7b0757fdedf3027ce994661947bf602cfb9ed033bc72cf3171fd280f1899513a0e80c1e0d404a724eccb0ab88919fac89e1630a8018b75c4717a1255238daa9b5a4f8533e13cee9ba94fdcad6202bd242a09e8e5d74e950334310fe82d57a1610b5294337c770671194e249ac3a893af02de9d80fa7ffc00978c7aa1a26d372d3919ab61821bbc0883e754b4ebab533eb19cd127711c60202eec89b82179dee626bc3fb4f277a21a166738cd60b6b838e7295e27529035494025cd3f2ab7561b8d9378d24a50ac5e4ac1ea55f121dcf1d231c2d13297717e77c2d84280afe0ae884571c7f7f844530bce9b0b37114990937dd0cdc892114cd1b6b0fe977e855a" + ], + "inputs": { + "n": "ab9acc348c6290f126cf3cb35e29b71cef8cf1c98d21f22276d540efb4f2a74a722d2b2ab6fd3e400621de109fa0c82104a6111d476da33c679fd58d32e32551e1f8e4b39fabd9ff7c6e5bf76aa5b7ba72ca79bb72eb68ad72975a6d1cebd0bec34cf56c9cab4d39f6280206b001d6495b6e1c58f3b050be29e078aab5cc45cc201922715dae7f72bc8810380a38c17b7838e6a18b804e2a25d2d22977fa26dc63161130464af47dd5c42dba70a85a0bfa2e3ca4889abb3cdcbecf75165ef6345ef1e58f9929df65ce9bf33a53e8f1ef18c73231c70f21a30c4c21f10693eba687faaf5de5f3b27e020527539b3a8e8358a929bca06c1ff6c3a2720ee19bbcd1" + }, + "w": "56e4278d5e18e72993067a600d455fc1758bfaf87f40b9208db96cca6317a1f59498854dabe973b91b666dbbbf107ceab92731cdba46abf9101ccf1dfe0e9a6ae10f7d4d37ce83f0846436438a75d0441d4b92efee0b65f6bf693a0f9315061a4ee17d6695099fd8aa81956f55563edd1eac4cfbadf69cc8f85b765baa80303e7fa1e61419b76945f3b47d03b86eab57d70a0301091b2ce58c3e42363c9b31df898590ff0efb93292a2f31ed0687ce02bbed8b44c157e8da629668437ecf4045ae7af3e4b766f72b521de9f8745112491ae0fd04bcbc5b5699e34ae085eee549e4151dddc35730aa6380e5e41118a591c1dc7b93fca26fa77456efc115c3d818", + "x": [ + "3d5987fe509b5af875a79c5cdb79bc1ccc4d62c226f324e9570a3bf2afca94d6185aa554f49daf52b2f3c7b5ae73f07113c08c70181315688f751a49920f1edb4f8deaf7abd62d1661557e2ad2550e5befcd5bb93d63f7f60b55e45bd62ac210ca1c12886bdc0d84e6be0b53ec38b6bfa289395f1a27757df84e30fc67ab2f384868190eaf7650c671e2a46bcf7a0264f2ca5c52896159c799afc09c908d84e9ecd6b4cdbb11ac55f53bbad0bfa5329d9dfc5fae7ed8471fa12872db2d3c62d275c405e7a019a53a2b2eaf21ee3c8d8de2d3c0950ab2532b1d33ca432c6446e292757ce5359f500b4cbe80423f66686cb1d4200e65e90f9b95ac10b215cafdff", + "76e3bea020868bc8af3695f7f08cc4e9c0223b56e326dab66d856c6f5f70432b41f8512aa8a7578be121feaa4ed488b60ca43187de2b2f10ec7035fd831ff25c6a75edd079cf5d45c9c404bc5dc8c353ff97480ad92e49cf942680bf3e64c897d4bf054d1e3cdac6730871a51cf93eca3f718cbc5f121b35ec1aa3ca9ab991d365f91590879656d32ea7b5a960283d774ec14a6257b3dcb82e4c9af8cc6149936d06e1cbe0d22e1c9d04a2c4e9719a654e1c340f8adebe9691261317ceabf0da3660c7cdb1259b8a8cb22aca075e5a4d5edbeeefe7c63d0bb9ee9a43edacafbd18e40a76c328e5ddb6865318b7c3e3509c665532072ffb3d3000fd0084181b65", + "6e8c67bb7c396e8a3b78a2ec564849b928870f99e2d7f254347dd4384ae7c5e6889a7481ceb0a08008228c141f7cd7f3264fcb61b5a2f7ce5fe52720c737cad5e2dc6e318f8c3f4d9718c451cf7ebf2a7d3363afc07856c7b0381fccf347d12da85534fcdb569f0640b6d0aa642d9b8a0fc4d469745a81cc8bc551998d14ba7c721c07d49c943f2f961f42d414d802d16ba050ee75f6b6336bafc178900eb12ce1a106ca3e7508f41d7356ffe5394ca9b3d5cfe88e94eefea56f4463479ac824fb04a019ce005b990ba32de11e1ae7a1b00c7209a5e4efb2afe5aa0b6a692bdc412049e7b967b83a055c776afbfdacb388843311dad7abb86f943cc664492753", + "38b8888f28c521b379f3a9278dbe5f80d09b55c9c1ca14aec26191c28713948b08f489d6147a14f68e56b11711fada820d417f6f7897434471265d875de94936f6e5980af4d875f410f0572ba2c5dfa63f114471b2cf86f89ae846c0a6214828991681f96c75a54a0ac51c270911bc7e31eb20c7a3f268567d00ebacf6f282d00501c06067e8e47cd18d46967558415c6d6e738e0bb9bb1d58c1436c5d8b66c4dc4654d00d0255f6851e2138b18271d0dee0c29d750a2f41ed791eb4a12c8682fb5fd8f99d50b45e1a4ecbf202fda0f41f4ef75b3a49c29320c6aa4109e33c755fbe0d72e4da6f28945c422bf4a63630f12fc7818c2e33b11d7fdfa09cf7a47f", + "71c9b07ce8909d5347255ede3ffb2a5be366e02b3d6fbbe7e5f32e58cc7dfd311778d35431d14c2eb3d2b1bfc1fc6affdb75ac9303bcf26b07de7302ba8ed2335c679aba48ebab75c614ab9fb6aef1715a70846d539dd4dddb147fdc131582637e172baf4f0002ed4fd0e6a70d0ee0c37b1928de6436ece2c4c3947b9b8f5597dc3ea8a6030c642eac3991aefff7ac56031d6c503c7a1d81e9e8421f4481525592ee42266e9356bb10175d2275d1536853440e3e038767ab47a5a10f991c53b15c3bb824091399118461b6b4d11036131a8f0d8f831a158215a66f21dbea5666a7a52f7306842389f61a7ee7e088eec1e4a953a17c7374e64827641a790d0883", + "76211d5d07d227d0ca4d2033f0db8b8f5c38450f8af0a25e837c6cce1836cdeacec364791e18908923a8eaf5e7bfb1f3f54afc3665c650fdaebd2add61cb1575c8372a74fde2660b7f98e2aedd0b12df2e7fa65c5aff8474029343cb05141baf46a07787d1cede0b2393b171a76d8a2ab773ed601f4dc4e1221a4a4ca8a870c559153a30c4797bc2c75f361af051a012c27947b98e8c1ee1943efa5d14ba5f3bfbafebcc9a8b9b3b8bbbb58c0b0e8ffa45dc08160f93163e2c875cd41e4e7e485fc50778e24e42ad18b6c5d0be781b3d7406a708e5728a25b2fb66af0aed8e01b691049aa36d3d65005ab39d353d881dd2d27fb42eb51866b40fa9381b89595c", + "2a370721fe11eb3a4150928ae65284bbb1ad673ba3fbd6f6e017715f7544dd464128dea8de9d0ba59ea7f1aec81880fed6103109e035e873dc996aa0eb062ca94a37c7c15911908bc36ceb7ddb522d1a703c9a7e96afc67898b450e2b21c57d774df693c787363443695610597d6e147430043a30915cb1cec365e061d43a34dcee7de5714bb6ccb199363f836f77353487a959d7fd8f529d16c40fcd65b36156859e7de7f229f68464270d21f885bd942a8e7cd41fa7f2d77cc11c286bd2b69693c99121d318f12622216f9db2cdf0e131c7b9fb403eeedf6c4e8531403e7433e3c04453d5e5bb797f9a7fe0f11686dbe2cb7617441ba627a4b31876cf6e4c8", + "350807a8985943a862625d3c80b05afcd8f21b2670f2077f534eda5b9e60522be6c6b5042e24eced2d82a8fa1e4035746ca56c751a9f8891f415701e0933f34a7bc2e7c238ac31ce9cc9ba6b0793cf5a9ea5603fc718683f8f8a613450fb3d52b3174424deb58be0ac36c34f42e1351cc2efcff22cc273062f68996b12915a69488b1df440079295dfa98611d839e426f203567cb5810c0af100859018d9c1f48bea7f4b41459fd12ff2613aa3b28be75c18aaf547c654793da2e29c5b5a3c10f9e791c67e13ebf71e51c70a21b3b5195789011e98501fbd8b6280faafa06fbc76c7be5408699deb4e071abc25d8dcad875db06dfbad2afe1b1ca1ffae0bede", + "202b0c9e94407d05d87fd1a58b2f0d99167ff4bda169f12bc35ead38b67c387215bb7e641940ff376475e892cfa9ea730e1ce5ac460a706b6307aba512ba2eb3d82927504421038d304228f8e39792605bf89adaaa7496107450c991895c9d08024912673139f1ee4aeb1e2608320a4c3837c5d5209ef96bdb70b63abfe60a30f5eeaea2c1908650a3220191929ad81b7b3f7b7f3b42f6fb93eb21fc00311072f6295fc5b80754ec69ad2e5ca9aa8db29aa948c783917c94c2830194f7257c0fc1ff2e2a788119f87936ffb524e3b3a8f34a45b6ab3fea93d883ac6fc240b8fa3026241ac77a99bccd806c59425c1ee2c14a50dd94d350d9c9a9cb764fa11225", + "3c0e22871c7a4ec6ebd6b00320c204f7a08f5b48a4c72a839fe9af8f810f92a747b95409c930008d1a9854d9ed444dca0cd5c2d6c9e33a9f56ba2abb657f7266338dc6280de992b717ded5e73341bfe83d59c9a82feb7075fd993ad734e1e410451ccc60c81851a0929757d528da0b7e3bcfda2a261623ebfa27f14720eb07bc04ac4a5be5ffd052644be12f45b84b81f849609df9404840d7c4325ba396c6fea46023815af25b67747189197f1a368a9e309e6afd568a13813d1a4ef69db08e80644ca45604e3928567a137e0616518d443621672ced35fcbc778c4c4c472a418ea7fe354ded784968e7964b55bf38e6255a2422e3a1e7c11d405aae4ada499", + "9f5d17d1e6e8fc417a23cc54337e280969b9d8481a257c85066228f58cd2d471260a8ff4095530ef2e590ef27e889232c7884af80e4fff63b8af0f60101e1d7191845d0c7d28b17444bb7a62716a351fd4892d5d4c57225447256437602811a661fa0e21591462370fc4bc0c4a9bfefca48947638d1eaf09f0196a87254e96c79f0334b49d8de3ecb237c820b17165c4bb3804dbeb27a04f82013dcc9ababd143c4a5ef382b303e7ee28431ac2d69ff5ac7889a07def1ce7f02914c76e42fd54df97738ee390f3412039fb03a1702f55e9ceae635ac5de81a948f1e884c11122b90aea7e6e922a1ae72d104b081d8fe854bf394f7b5b3fb3e8cc77b832e5036e", + "3b12b9837e9f40e42b46d0843e9b4caf138c76c7a386eae925ad9e3e1aad67f498e1c94b16192ebadc3e917a5cfa2502fdaaf947a0246e92c141660c7e06c15695e282c507618cfad016393a6fdcc12371878b54c20f51388983bbdbb65dba5e6a09517f0072f0a25756837969fd30f34db2e17bb312d78b530b61d777a502b629c789ea36b723cc67e22f626367ad95c144463aba8729925c35d4556c19cf39a7c860a5bcb1f67bd6d880432145090666c3ba93030bfe751348f9c487d2caeb62eda5388b2357e9952aa788d197e5a1ebee6dcbbf64e4a7d3cbbf5f98a6e179fb2c52b510927736f00a20052fa53a7f9f8a6fb76d5e272c0a4babc01d5f4d09", + "377256e2337639403d440fd4ac34aa36906ec567d50a812e37e7f0e6f71f64528ed1187c943301033098babf37d11d68121cd745c7e25fae2330d747cbff7194d1d6da1df5666254ba08e55ece72b4592e363775d15ca85be7b4e872794ce61203d41d06d4a39bb29ab0b03ac7b5e0284a7be2659f3a38b27efbf5bd7ebc314a169e3d8ac62d05dd168f64a3df01a2e24299db4d225e0e7976dff916535c4dd31292ed6f16b3bdc3d4061aa5b5e44e810144d08153c6cfa4bc550b923c910f3ad08ee97b0413e9889a9c895059ace4bc7617e017305bdd4aacb0469acb3608c13c8c92d8e0d4950529c2ce15b1386520e14784cb6081a276be27adfcbddbc0ce", + "35ad6c0107b0f46b4ee8fc503601c6a4ef55d1a8defe092b00c01562f02a4a8a2d1fc5cdb772908982e77217a18d322ee2725c44ad47f5ed466887499b4efa3b9661df83abfe3340ba35f986e397769dc9851c5e7a0849ae813f26389cd09d8542e4d0b843de2c5b4fa08a04d02a8a46002ab127921534f6a515dad4e1999628e987c7bdc447d5b5bf01301b619df7f56ef151e194181caef49260f30b040bab431019e1f561808c38c8656a9c309543a7e5f440b3ae2af21519613c2876646d590b0bacacc100ab4bcb9061e5c5875025cf24c0daeb56f2aed9c4bb89d6e9b7e2dff4b5aa560cb04ca8eca24d30788416d55b4473ec0055c93aa78383567ed5", + "67284b4829dc8b185fe87037bfe574ef827d1025e88c31cdf4d2d2dbb1401d5c60abf9efdfe3c2a836d78227ed8342bb776c13953b4ea7def042954e420931026856595f137072982d52c8b0560fb641c466a3fb0869effe03ed0c24c2f99e7086f0fa079559db22cb3dd1d72d97fcb0c05561da356784e340e8beb52e7b39786de22e8bff73e9d5c7f8fbe12d9e111b6453370b93939cc5af5c66c53c79fbbc35c77cdc4e6681eced63c8040ac3cec18a1475769da1ce9e5eae8a5cc562a189d6c09a0f19adbfce3d91925aad7cea4ed87fb0026cb6b2123d14bcebc36ee75c0ac25879bca7e8de02548d19d72041094c60c138cfa2cd3b994849083941b7b4", + "26be3e0933b148ae6d51fceda78bb5166cbf49d11346e9818eb3b3e11cb418b3dce5f5536563ddc904638b18ef128d2fc036dd5cebb9db695034cca44eb637694b9fcae30fc1b6bf608616246e373bdbe197071106fb83b99aaeb351a4056ce81585e1d537bcdfdb7ab902093608a7168e8f303a1af760d499e38274d798eb6bdaa8a2f5c0f16bcd9baedf74e43abd111a3ffa953c85bce1ae80dbb5d42914ce391b5c083709863f51ed36343afaf973f64703f017d1594426aa14e52632a298b09c95c09ddbd796b28db40153447fdeea608091d211e907c60d7b260702fa63ec3c56df599bfbdd748cbe7f8a31adc27c3252c94b619ab376f7a826751a7dd2", + "78dc329784b37b593ebe21cfb909042acf70f3f279df4826109e152367c84233a88574bf73aa46a62f5bfc1a782f547355304de11bfef4d1d71e6b940767b0b28678f7e229f97e0c42712cb378601c3fb08e649fe42aa02c2c111ffdd305b3ef14208965a450ced77eda84d606815cde7bb4f76d946b20a6afb25802d60a301583ad902a2fd7df3b7b16203a689fa970bd21270e199b71dee9eccc34ed535336ca3734bbb0dce065d67a6507d8796e685312e5ac8394b826c5ccf51c7961887b3ae56af29c17fee694a391ab7c911395f21fabb386fe57c107d42c6dfd8533ed982738f3d12cce048bff8e81e8af309181a96722990da49f0da0f040c00a6383", + "367169e63916195dbb81580c116f0657f678a43532b56f132ad0354bb1417468588f045580d913b6bb33dc1b5214b7ff4b93184c1f605ac2930594fd31d7dfc27f832e843a04b47595486dac642a1698c50966b5a8bf8837dbc055e7f728a4f636af7a338bdf1b7cc726de42fecbe2b7bd830de7a682f703b96f1b434ff63fd8df329fb949c9bb4c632feee7d314e606e27bf83174b00531035b2957008d491ec8a221736c6a134914c9026bf8e5c25e9a3ee67d80bb6f9eb5cf1ac31c4ef57ebf3270abc5e14ad2635643b99a9b5621a5d59af46b0dd98926c53914d5622f00effca8982c0d1f7b2c56fce1504b77604a85c9646e3e8b6aa8d8365af5410553", + "5541c831c15b18a4c30e77e85d8683f1d4da6aee3b2c5e421ad52eba369ff7f6807e6171f4dfe9cc6689d577e66961b5684d6f0e7749092c8473291e94b1ac51385608415adecc4dd2535508a4ec5ca0c30c2a012c170c6ab9904e9ba0610a1666546d5cda8631113b9c5df4d5818f960d15700f9d4c0cdf272131b4f2db8a240a041a6bfeaff8eb40320962e0eaf5f88a2144bce376c38c0a4d621cc53b05a547f7d264af0fd10b87f4b95886f2f54faf42b1beabaa74556d97e641e1a8f2627284c7189489e51beeac31ebc0811498f8a8b182fcc0613369b3506e268219b1d83d65065347c810dc08b50e0fd60c66fd132a9163bdaf5b50a174a5081acafd", + "828981f7745317ec00f57aaef1176fdcb9d9f973941f743580f34daff77a3d07ee794609d20d317ae03c67c0f942624c04bf087a8ac6f647ed12a2c6ab2575b7d5c1feca9ffabb35a57f46fcf82d6b527c4f2bb333daf5fec37e90b8ea83918160eb78f4e4c47b6a4f00b52df908ae190300cd15a37a77c442e32550b3bdb0d296b26c4c39800e56a2d6c4d6c4587c52d21a16d8473dc42aa5afa370bd1c0d3209a86d7f1236758e5144069edf7194afa154c7a33e3479ab958044f91ee62d3a21b40461c38fe7b9bae5231eafd30dda5bc3903867fddd142b33d2c9844990638f1521a58102704fc55cf48c1c6cee0b49f955fdac3152ddb6617a1742467ae8", + "2ad68b03c5cc5cf383f0d9f18c54b882188683ef0031510b5bbfee66bd37255883ae920edaa4b3b4e78b3c471eda2758acbc757b770dddac770b38e2219fa916266b1205178994cff9e8a842c0dd9548c5e6f0be8550887aba6105850aefd7d64b6e7fe9ec5236412baf964d7865a8d8fee7f86e1797aa83658a7a9143499a2b86f2847f079a4918d75dddaadde23fb4297467667cba66b8d8d09f772f8d2b5b6257edec1ed7f7f44bfea2e70a6908b105ca0f3b6146e7a70b441812ad477e02c3a9838bf12c2e28bf8974f458b933ab56b67cca016ae104dd5b8c9b355d23de5d190b54ccf7b697c942249bcf3637d0e49df91c308621ecc03be45bd8944cfa", + "4b824a40b8541bb1c11890e3f855c5cee53f6d7d368027b659d7ed5a2dde00ce814adff5773f127baf3e38c5880c3644fc27594fdf295d3383021af47f93004fbcedcfb86346c485957388b08a36f1c8b15a88d4649ba7463de77cce4a1e6318f14b03d3d5639c5af96bd5349686c50757c957b344bd180c1cbdf22c514ea40fb28685a0f532ee300ccd38927f68763ac37b5a7bf587d80a8f19879e593f8121eaef7d457d72e9a50ce98a3a1ede47ba3ec785047e96a70bb7f35972b797a90b22cc414c0ee0e9393125d65d5895873e46b917d97352dd5c7b6ea63733f99e93b8324976a45a5b993ba7fdc947d0e5f02531ae8e5feed4824f44f9dc0a6764c6", + "17f65301bff1a20d2330078705d3d19974c657097deb2fae2b11f553e098c22c5ef8d3066cf1bc259aa153f5b60c062484ad546d17e8bc8e83415b1598374991dc1a3291d59dcc153e0d5e5028b35da7f355119af7ef1be76ec621b017739b224ba3f223be4b7782829dbd5d7b6c56bcd483b2b2e59c4c6ec6b33effc34063d4e6099029a0b2bc55ededf3b7dede462775a51e2b4af0d4f3817c456b49f100b7058099bc70e7ebdb338d653ae5f47092d2f6724be045a31af182b9387e427d6a27275242b932e8c55285547ba122cb9cb8081ddeb8114fe94b68772d03f8559d5b2bc467ea2a35f7be054e2bfd4a8f370637f7d4e8ea5e7ae472b9b25090bbb9", + "7e170b90620b2494bb11f9983f6a0580a97972e1b8cad82c30d47a5985ccc84859d8e3dbecd958ed466f435846159d3f6416f7cd6c6cfff95179dafac1420c92ea2c73aab6c6a6d64908f1657b0ad09d290c0d6e30a5a73cd2554b28f93665237119e2355dfe6ab7aa03d88c9ccba8f20fc4b117e86c943e3fdf3c2df7e73165796ffff5c4c150900497400d8f758a53af8ce52564ec0608394bb88e5c192cb50bf2bafabc9529545b31c52571b8d22639e7c5d692974ca62b4d337e8d5fe3bab298f34d6f9526faa5753ebab177de41f25b91f058c6edc561049772a44dcbc8932a284bd0ca1f10550535efc30247d8b26805e79a28b9097574ab6b40cfd40c", + "7823c187b15f0835a73ea1ae53bd6ba91db9484a9a49e7480f53f5119dd88a6c1004cbda3714fc31f4dc1df98801e21794fbd4e579541d0c9f1f3ef554722efd085716cf1bc7376f60c13e6c3e29668b5b9ab4ad0717517fdcf9e9dc78fc06df77e4b1e9e5f40e0a801cf10703de33f7f952c28731c3322ab0e7b8a2cd4c124c359b9e3d3ca370f186c9ac972e5b57d290691983fc8ccc0aa4851c38b29d2647830d385ddc6cb384a2359db0ef5c45d8aa5b90a0f59cda1e63665f68bad1a9a8e3444faedc4bd0c35d0f30ee207c767501730b87e8c8aae70518b60a014686a37f231b6f003e0b5e06e01e981615a67ef6026c204832702a3e9d154f62da0c9a", + "35099747a6e63d8cc61ce39c9c574e6a899d94ecda14c2a3343f67590ccacd310196191454c7db8530774c9108a755836afb2432a80e33176098e8c3bae0f0dd73119b9541a21960ed02a524066a48b5d53eecc1766d4bb8a973904a2b2ca5184770a8d9f3a77793376e5378417a6a16dac10789f5a46ab3a83651f49d60b4c2f582212bb5b32b2149ab836e35ce35e355a5c7115fac68a79458bd3c13fd9245be222e2db0755e9519e080688dc232bd60ed985652f61ae96994b06792006fb33a55b3f5fa14a13543f1b5d076cb1f487740b3f5a883fadac80fd8d82cc61409591f5d4dbe9f0c998709df36e4183c4dad54502e8f6d4a16fcc5c1e796c2ef86", + "511ebbd889ef054bb614f0d765c2b6b8b25edf51ee8e319b2d270fef136f2588d12dc81da9fac7eee1380266b14fc53974ee09a8d3f54bca179b4658e5401aed77265efeaa1855c19a623275339ea629b9f1b9a3a4dea48719febeba9bf457166a6fa783f9930830e9dbc40deff11995371646100548ca43b742cdea7ca6e4affd03dfdc6539da639511f2831e0fea4c564d166ce8559c47fd6405d97cb1aabfbcce0dbfe3c8d0a230b2f8c1e6d3ebf4c93f22d211debcacf3828e7c448a7e9d5ee1825ea8cec515344c728bda2354e5ae1af329bc62d4ac21551be41bbd4dd5230ee8ed78040a49109d36f8a1e7444690faa00021bb0334fd0aac3c58b8aef4", + "29478d6d516a7771c9497bdd02df3b709c7a345549c44b72d3842a646eff80fd248f60d3f7d6baf38bf40154410df8c68ec8fba2ffa6c8c2632d401205a57935155ab8a69e939b00103697aca6b8e0a2c356bbac275ef556ad592c5e492401415c6377d7fc4616b85453936a5490db42cb563a9007fb47fc2d0a1813c709b45c8112e9cdd35257413913196e06f521a316687e15ce9c9c323d09051ef8d9c8188ba14c9f9487176c331a8313f838af29768e68056150e3b244a5899aebaa480a1a71630ace6fa05ba7f78504f3b88e987ec858379a526bd9c2fde695fb1e11b27e92efb263fdc4c7490a78474e15bd5682c1054a0754deff44fbd0db26424139", + "2cf73e4e9238e1512e525df46222746801a72b0b0e2b311abcdd5d254176a575869a3e61bde927769b1c56bd84ecbd3f28e30ffb74f31fc0b09ec665f0de90289a1149e2349e20bc55d2767b464f239df9504709980edbe9d14b0a92126ab52c5033c573993cb77d6c126eeea2ae66788279775f31dabdb5e61d422850aa646ab7251de33b49f457ca0a07c53d1df79b3300ad447081c72b13eb24329c6de948eeb9a7a88906c2e688adbdb07c2bd21aee4ffa2a981801868b422736536b0bb4e192727e05d3754fc69e7db151fccce3cf2b5893d45da0c5a660791a5e76bb6f21fc529bca627a0a67207e6bfae2b7977a332d9ae3abd9c38c1e02a1dc7f0330", + "28a2f7264ea8c4706ee9e8e7efdb92b5b8448e0cece16f627ef9a2d0a75d2a99a678607420b4c93664c1f093bfb7f71a14f92757d1b45a2a06c95aa3ba0311023876edbf150cc089e2f7de037c190ad7720eb653e17a12ce70ae959e9c39fc2cdbacf13ebef9972461eb21c848cf633e9126c3da02a26cd3737f49c5b612662e61ea929a877057b13b5c6b611988c83f24d25be98707985b910f88b19ed17d719b3b23330c1864676d0ce447a05879747d7b7a5f411c30d6e6c42da12eed48e6a5ff98fbcb5f3d13445591cfe1ff3ef3d1bcef687df5a6337704a2d710c9a75158ea9b2207e818a4f35c0be59e871329df90bb2c328974d212599110863d1e99", + "663540c60ca2a4648e150eca8eaf43f8d4c62e54d4d0c558b96d722b6287fe26eb504b6fbb25b36d4cf3a535ba2014b69b5745b758ca7a00d8169e37acaa376860117390d8ba914204659387e97806669b34010041257cc158493b5adffdb1f0b0d713ef2fabe01d43fd9cc10ea4f84705c49de6b3e05f3256c71d425053d654f20ec5e546b948fd9a3fa45c154358f636bfba2979af9d33b11e832f5bc67d9701e31ae1f344ac4d90b70beaacc5421dbcf1de5635af44163975aaeb10b2591cef39388c552f6d06ff27d5009f501b55d008fa522a9f57da453a6fe16d5f499e8364859a68e23710a76f274f02834952f49138488d62ef2bd4db9487aef76f80", + "344729f8c0c10703f1988a16f9d40af318efabb73a445837d8cf55a5ee62329a05c833f677eef0fd87fa0c9f2cf77269f34032434ba8c909ec65febb76fd36ce1e7e4fd54d3efdc400e06562c11c4813f912d24378afadccc7f7f46c3eed29c0dd406923692a1d782a2ff7a7894b2c81a7f2cb2a2cab9f3e078bbafa45b184ef730be0c46c8be02fa5b0f2c5ecb011e86e95fa8b289ca3699d3001e7b91f18aebdce048db98c342d475be15a514f0503740621e6d489ec2399652e0ce07e69aec9ba11c74e2b17c953cb64011ff0332fb968b543f38874049c3ff87b7db523ca93303b14e29e27c85789ebc29805ca3bdf9417053afda63750baee4d3590a862", + "43c49c72215ea2ec770698de647c2eb0847322570ec70a05fcc3988acccc1b5d08a6a5883468f6be263428ccf55744b3b7d5f45362ab53924110207d29524fb66506fb748cec75314e128177c15fa7e11a0d51a76c1f2bbb23fd739e1ece7c16077faa747966062960519bd629635ca892183ebbcb226dd6614b32b60bd6177419d1bb7516629eab9400fc4f76b9ad17486fce9a5ac8e2e2222dd88b93ebd953a150b12023b0cf336dbdc1364e6a86403d7bd962d3f023ab18a78717b708ccf97cc70981ac42c52df4827859ac1ecf56b12e982f2ece6db9130dd8106bbd156f796694dd439ed7cd50761d75f6adb062ed78bdf56867f6d2f8b8ad0d0f1fdf9f", + "1f453ee7d5935f3f41b94307ad482905e498f756fa22316cc293dd5a5a0169751ad685cbbc1f094f44b3b8b645bb2e910749ea540513968411fba91eb3b6bd6e37f96a2518902f5a95ed75b114e5044bf514e10381f360fc5a4ddb211ffa6b2caa3b1e8e4f14e4bfff8ae2380afdb544aade2ad79c5a82bafd6b6393d14347fc4e4db92b0eeb7db9eb97f20ed91d2b52e242623876421618c06bcc77761510e51c01b9fb325221b4cc95eba08776e91eb5164c049dc04435e0d506cfc2723ad0874d53b48a37c7ba77985d469941b9dc4d660fd8ff7ed217be62710fab2504dda5c66dc5e4433824f4c427c4ae9bcc33a91074f860b7767ec3396424a623d681", + "441daa103d8d31230be31b2858e21157b189cee71729f2fbcc63c9fcc6481e7754cc7cefe346cebd1f97e95fb30febe260662ca41592c78b533bad8597fa1d96e5aa90be15489924dd7ae237076b3d57f5e6faf01e553d6df2ae1cee83afe75e0307d9290893bd77f2b81815a556bcc69ed62c90d87bd32df05a417bbe8c135d04e9a763a9c2fe31d894d9911bd9f06981a2e0c07feec516b3f4db60f0e2edb86378cb92f3ddcaec876e33f32d59d346bb23a301b81f9492872facc61530078a7b7a620510165d590165d8515a07a1ea738e335a9db45e160025a94b541b59b091753ff4a33ec175648f0f3d541df2de2f0931f3c302c485353a61709687f431", + "840c621babc1abf61828b2118521aa64522e00a2940516f92f9a180966fa00a8073f01d0b2c8b60666c5624c8d5d3a942f1b0533f287e59ca770a97e0591264af5be0b58b4c9d380a08d7805673176ccbf796cca8936073fafbcb1d62d706aa1e2f38749dcc517c195c1e48204e3585e38517323035b9273b52d7e086a60381f284eab32076d00c47a1ca6191d8d03bca1e7aa5f5ee9ce7d6c4f997bc7c7d97df6bdf8c6825289a4e420e54a277087c14cf1c6a4c0b02f5f028b70b95fe7ebe7d6e4423e8c4c88cc134567cdc9c5ba67cf4c723ee800312b87d0f73e8aabfc926dba6b7b4a42d919e5bd6748951c2c15e2572f496a593dad3264a29cea9ff9bb", + "678bcfc408e57af7d328ac78a8eb2cea14c7dbf68182ed6827138daeac4c9ce84fc68f5ea1cb473daa5598534833ff0b3830176eb3249670cb0f789a58f0d397cf0beff409f4dc239f36e0280ee649b9300a560eb54008b4fc019a6978741c74ae0348bba68ab029ed1faa7f2e46cca416bfe698cb3c0cecd57b16c9421432629ac3fc8f3dbf5abb22879a121f15d03acf43172b826cbf5bb5bf2604548dd3c9ce649e66098de5fd360c7510652efef3469f1a8bf142f60953aed6378a129fcb5abe30228151883de675018bf090d02e00bfeeeb8c10cb9f50a927b8a09ccd2dbd5ef4e2a7dcc7653fe56beb77c7e89c999f2354c8123f88b679cd0b0e323b84", + "1e4d5b13baf744c28bf9d39af65102ffa477372b203360ad2b7cf1c0f07945d545259d3297d1497c3ee1d717da1ea86ee7ac1cef18b8066b2bf6fb536fd734a1e12b521a746ba9fc483ac8c03e85a40c2bd2ceba96168c7ae2fb3a5521ea3290e0142a7da3736e5d48bc02e12b100ae415ed3d3056ec555de880fe5ba06ed2458570e6f8869f365cc2289db2bcfd3be1cd4922ae21d57ddc9cc7e9c215c6b3cb5949d472e2684f01253b77001747e043e466e8942079aa35ee593d6f97bf3614cf00bc8711eee20cbcbeeb2166d38f6074be64a765bdb637d96b15c093237b38c7d22691eabfa53246d48bcf6ff9d4ff471d71fda1f53de51e4b3ddd2e5cf929", + "e6720efb1926d1788c3b08b73fe0a23426b402139d439eae126c5a9f210ec5a66c959daca4c1f328d88a133ce7e8d1b7fea592cbac8865e9c6669186a73557a8e269d4e2fd01d97e7e027dd91a3e608052f08e28cffc58f98f199ea9701fe70b6d5e81f24430535566984f8e8c168ed1ae71d50d8d98fe57eb05ca05acc78fd9464018cb03bcaf74753b7aae0bb6188b9a32f146c721f75f7c8810da02dc1e4a8806ded9d408ddb6f6c9e622e29c3208c78f72a0a5a4f93be44f84857327e764a7bb42ed8d72c91568994fe5a3900abafe25089ad19e1fdaccf299406d5492484bf66180a5c5524e7631dfd53ff0a83d2c92a58e9061ebe83135ebf450b3d3c", + "a3dc2735bbb84441ed16c37298aa262294f8ff75f4e13f1343844c07479105c98f5fe5757e204f2bbdc0686280f2810e3ff98c5b5afc9a668ef5b540478f320d47055078839cd184ed4f0d4aa547aa3c6f3f9c33c33af97a71ebf055de8fbcfa55240ad792fd501087f93e4c25dd0915596eb2f82538b1ccd2ffbb86ad3c5a62a82b46ad2758ad35b383a6e7a43f24ef9577018a626389323694563885335d8ac5a53a11720fce36719e4036cb9d2d9826964f0af5d2f2a07f51654e9afee3b066d34477569b20f2b8ad8d03d4d7c6f850ef3ba13efe8241f8928e32727d8ecea5f8d0f8e0b958b22d0a7decc53d415420cb751d3ca1f71f622ab8fe7bf4828b", + "41879ade1f3e346ed4bccc6762ffee1c2248b775d9d3fc857bf50423d015fb98291829ed150e11f1def93158cef447e4e6b2b9b7824cebeb876dd198009ab824f30e04a24ecbc484725b60a8e7d36a5ba59115743c306cefe486028cab0a1903c505978b8d1e9bb90c1e2ab42fd3e786f8721c74c4b81544b6e985d65b1688ad5060a7ceca18a0bdd7ee7b69d63339ac8b31dd2077de1192f8ea2ebdd5c48419205ba6b005712e70abe70b3627eb9d667604c28c861eab2ba73e708a1bc12b2a329b983709960c0db9381eda939748d118d0a6164f7b999fddc187a7e3a4a06a2c40b8a1375eea8a080b6844a90d1f0cfdc6b26da54cedc6856c24655219ab1e", + "772e7e78c1a820b6861425e6dc2c9c5074ca003513c9ca9faa93ca13d66ce21be09ea620c82d46b4f0596bbc5af31d6fdee5b6b0a3479e56e73905f9262f58a372d706ce7d864c012d4284a90b2ab02cb460c5b5ba221619376b4b5b60f6fb604847390e1c06e6200580853068fe1b782db16c8f449d2f94770a9b8d618a656ef7baa92a8d8a90b20143ef02897dea46a88dc00e409a485e7add068b4a5b2f524da8d44e742431d2c836b9972067d417aeb6ffc900483385a645c6e463218fee0d87d6a91aa74a5e8e9db0121393a225e4a2a7e8c672fde07ea76cf8c08e2ca02df832e784c35dfe2612b60cdc8ea9a11ef14578e86c21b76bf712503ad3bc68", + "95f0f3201140b089c0a44a9e46c6ae5393bc73cf9c0bbf948e3829e08be6a4d0b99c9c9743f188c59b38b7920135b9a2c9ec7a6970f8b95a6e131b085fc2914c036931cdafcbffc2acc1ce46d8b88f8d0eb23c7dfa48c2779a8f45934a81450470993c0fd63704f4e04f5e3c817db704308ba1c0b90f019021d332da8f9338a081ee0c87e8f61f74c4de2508a246b446ed6bfab29b53a4519f6b3344f50ad3c3f1b1c23af4b4778a7c8856172b2fbb1ae38720241fc7236dc8b70a0e5593f1b5da1b631f11cd2f5911b29b140e35c89126d4eb7e55a77b6be1f4dc64f45f237bf9e5b955cf74c20c67306088c3ae2a6d6ce1e7e135431262b8eb9508d74b4662", + "577984ace6feec162597a354b3c594b83058cfabae8789eb8546180862f24ce213a59be81634c202342139f1376a813e947f69e3d7e37803296f0391fa351d1cf384f0c4512490118a61bd727c4325e95b5551fc8619893258cdb102dc8dbc5dbba26820e3856eb2fee287429a8991b5e5677f75f68871ce3af789254d757ad2a24b660282030ae4e5fc10e40d3334ed787bdc480d21947f60e3b47db5f23661aeac8ca686a4388724821ad576260a483c19a3418c0b56a846602c98e1ce6d97b86239443267faf9fe854d3bd0112fcdd6129aa26f5a0341c505b63a6c3fc20a1ccc2082d8b1db2459d4ff044d0c7c5b393bd382fa171253f7d966e761c61bf4", + "88b08592f6b6077e685a537fccf00484d09929b04fd314600b76c453b4b181fa6bed6acdf260b31eec32cf8ee7541688c877e970fb533976adde9673fe6d872f1b9ed14c7c33ab1462891629eb7cf69c307d8f3099f11eaa5de0741a56a83c284fbfe7f19a156d70517c4ae5a096357cad43ce6a13f5c11a06948d7868afab7e7adeb03a61f8e4e442e797dc5a0f9866a5256f1228b84c14b129c4dff1ca398f0cd0a296de2cef79ce96cf59bf92b18a8fa1515b2ba2bed40b71160124150a10f2e59d1b4dd67f822140c26d972e742f27dfface525cd30ff6a11df2d06cf5a4be2520607a88149ada0fcc2f265718b3d9d8e10583764e43eb6c487ee82b8032", + "5cd61b2a43496b82708c22f3be651517460faa4fbd54cdf629b11b860397a6b8238995546fd510f23dc4b0cc6db41880a881e2f1772906fc695b304d1d4eb82f09ad3faaac09935831d574ab0992b7bc06ea42f993352d06317fefecca76ea4786eacac101ee9673bec138d6520e260a2214013339e36e310c6e755104245c75d352adb832af38e5a2ff8f5cb0df6d56cd7d424f1799fc6b4031f6911f0f7bd7a11d8fda8222b1276f4840d517ef331a89f59078a6d7b8b485cf80fe6b744e9be058855749480f0f740d68cc8eff8565e4353c3d030ff7682695f2efd8cc70d1f8e8d593447537041c09b76c18855ef4af6f81ac9301c8fb4b2306fe60bb7484", + "24f779e0a63b28606a1817e354caaab9476c956906f27da1c76d27cdc32bded42eb8d7bde6cf20e8a9319e8edddacdc64e913bd2929b8c724e4af99358b8aea343faffc2c7b4b35a351669e6d099bd6589a18cae6a40c396e0092cdb9b3d3e1350b0e2d316577ebbfa62832de9ed82abbd0aadf046f20fa9e4de3387b7b79e37e73e90f3835c1808c5cd8f7a52c97bcb2977cc291d9dae04e128756c175fab60067f99fe61244166ffa0ae17ad1554dc2765625639a5fcd3944b4c93a2affb904513dacd0ff0a4651a2f4e3b271e6831dd5d69cfc4a31d534357543476f323de0cf5f4dc41c000081094fca772bcfe645d6fcb463e3962e70ee72b1800def4ff", + "831bae645fd0701b3b1365aade2151ff6e4a80d91f8084f6923188c33f1d1f29225b21d458a5596830d2ea8501839eda249916ed70c881d04e2792fe95557324a673c23d98a13403ea0c8c8e425d289c5d66a38ca416d91d0bc6c9edab5fe92951ba5c3fe33452819354b0c475b8c5b38294de879ccd8a164b23e143b44e19e5b21367f56f1b9be425ee2daea7395136cf1c1cd43f0e5c48bf5c54cd70d8c14beb747a4867b9edceab7769af78f357d82e9fb6e28587fe1381d84797bfb6d9482e9c1ea957b7e786b22a31256fa9d3d899e72fd148795bcc412b9d5b027dfcd9a942ab35f49a33729aa7e513dc1019aff45aeae9f5b23d816a48808dcea722af", + "5bf17608afd8866c429bbfa5bf37e65cbe6690f1a872a7bb0c406ba6a7f37df745b6e617d2dff5dc22b618504edd64b1f81a7eddaafd8e5d825b2b5064d2b97588889d6fb1e255589539adb4ed9e186942a20e43f4b22a8412d8eaa8ba36c606390ddf4d37ece28e2d0b856471e63e516a3355e08a69bf3841f5e1ce9d7c6fe95a4bb890e4c0756ab41221b0fa1d99cf88e5dd72f935c7828bef80a26621ac975b3b484d6942c63773cd570587404b148ca455c8132297f395cd40a34efdeb39e047de5e46da895d0b4ccc008ecc82db1da48ba7c3cf4f77ed0d5de690adcece9e0063eb0562f295197c6dcc97cfb63637ae9a69003b95f66b2c47b9030c2e32", + "828396a036080e6503b3c0b8944285dd9f3a12c5ab2673d2b721f2ec31ed1669c5ae8f67fbca9a4100eb6b2e8a9c5c0018bae174aff3097158f82aeed8cbe2ff429d941b9db7436bb4db2b360a1031f2b4de7ac1d3f68ea96189489b37714cedf331f8703c3cf75a52ad67f4c4124df26e34608c4065506a53e77dfe04fc59807651566737e5e2d31ab556ca1cbfdaad8db847458a34aa75eca13c8fa4b9027610dcadc0639e6d47a8491a1e26a7b9360ad1ea2e5fd5e0013864a7fd267f425f761f31f7aa04316b30156835a6676e54c3ee948af9f3c2ba4f9228de0f14569026db18e276edff8453e1fa86c819dcecc80006b387c78209e6fc725a949564a4", + "7f50c49b5ddb9f7c531dacca12630496ad3b32972ef87510b540f21d2395dd4552a7fd86da079c574dfa8ade1e503b5274f35a36c7980cc685a61ce0624e904cd43bc123206c692bfc2dd989f35dfa3095dfc83304345f2931f66adacdee2c53e4e5fd8ad0c2616c4cf43aa62a47230a9c85c29bcb3f2314efe1c372f0180494cc5b9f0821e5b3ce57d96a8ea96132218ddb588dd945cb2f291ed8778e41d3f5bcadbda3388607c039bdd8eca4eb93071bde9e8e056246519709dab0182ba56bcd9bc78010a7a786907a742aec6f2906137d4f55a0fff9cd00301cd07d91d51558d1f7efa6c829d04aaf80047d2a78e97ca4bac074103dc01ad0178b103d0559", + "21bd7278035764d7416bc39d22ae44d36685a26476a88f7287884a39b3bcda6867fb334cfad4842a1b39b9cbeba7725e376b2129c729f266b1d4fafd9bcb66f35e1fdfb1108492e8c43db71905f616c18e56efc0fd739bf76720aa807e927793f0b2d7b3d2ea01301b6019f975a207c46102cde8a0ef6067f0ffd751df1020a555550907474775d0cf6a240c5c93c692a80191f3f5e2ea2dd614eb805a4d157037e3397ffe6d092827c3a2cab72c6510a722becad5572b0f4ca3be1fa852476c877103fbf2474aaf403668b4de00808b03d061092d8203c4007a4cdfc481ec04b152cf79254974ccae32a914023aaffd87315c62d7a3af798ef913cd9285c640", + "5c2d0ea99c632a4b4c8e5c1e9f772de9d8968760cdfcf85c37e21a19726d3138f90a2f7a1ec47a19e01a43c31a83773d2e0ff6c30418fafaa2e872d427b7223ef66f73513ccfcd927fda41490fa86b77cd954247d02f4f2311f90c7c9b5396cd27aff285e5ab6742a7df638aa67288eec68a2d36b973b4c6a98ac2894e742b79ede874fedc2bc83a1c9bcda34cb7ff9f4ff1af9ac90f82417848a14e04115e859d8b1676edfd7d529536097cd30d69b7a205b430e0fdcd3a147d99bd60a3e2042f71b301a6cb7f272e978ec132aa7e5e50be21645d288060e8824162db55322b489deade506522d5df8139f7f05ead74385119ed865fd9f94c02d5cfe57e3db8", + "74960ee316044bd0e12da5d7b9603dfccc45afffb265e0fa6f731c0734829bd8bd10f9fae1a51f015746022ab02fbea089319b67ee708805f2ebd82559a95727cd377952ff1c5699d8df36eaf698a612e74260f000f2dbde9462606fc32ee6277281eb19084560dc9bc7d69458c51fe4742e260f343e24a94575c7f93a1a72a8737f8e6d4ca67bc254fb1420d2d10a8ce657c090d19d4a0ac7d6bc4f212c1f5f1d816e95d71eb944853a41382ee13ad60dd019a13c77e1952fbf45ad1c8964e18557cb6c403783b02c94bb7c22dad06764ba9fe8c1bc35e494cf83d60c9aca917572f11d4a1dd02466e638d4ee7fc6f2804c52385a7cf302f9bf048c70cce808", + "859264a399150ed1a140598d805475b0718c8652fb14350fe793f7538bfee2d8f7b014bb317042d2bac641369fea38996b226835dc434b5e955e8649d74f5fbd7bcd4a0bfc14212a918a7ff75cbfbc565f1d824ac6200e8eac5186b8faadc85ae37a28a0f80772314821bf4b81bfa7773f043c960bc849408739c993afb31d76bddb981379fde9799a830a65a470487290100ea586e2ea16447ebe099e0f9f7ec3db0a2ab182a9b0afa75100435be5982dd27e8c72d289ef37a862d428714d86416ab51e4745d993a7595a38ee2b6abad7b526e5a2d1ef316d4e90de06776079d41d6a4a82f24079a7b003ac0463f46469f103e3cd379bbdd11c99fcb6462f9e", + "56255fdc822cfbdc51018f5b098cd4f1bd62d4a691bb9cb3dbf279ed7fc41a51977a63e6eb37fa88aab9db4cde433e02bbddce752cb0fc82357eaedb54f5ad4b1e28e40120648eeac27d5232a60b8ffc9e72e69b4d1de8cc6c1cd0b9b1e0ff462289602f73a230e55e1657a12947d5ea3bd069117500d13c075a2e14f5f5611f11f260c7dc2b7dd8057ce1ff5f73ec54d8fc0f7ad5c5fcb460e5529f95384b3c109b048b6b3b1e8da4c0d8794ab69d7fb04a3cf7105cad4f6dd04b4123c28fc382ffefb16d0b59aaeaa561240fec6cdcfa53f6fda9ad90f722476231550f7d7e0aaa69e4c9fae0285e1fe19bc431d9ce24f8fb28e8e72828dd454e9be2083373", + "80699c5236e484f15765105baf6de7db5e458f8105a756c7ab2a8476cda5a71332b699727de6965fadf6f005860dc0206439780826ad8adb5323c05f91b162cf7eead165826e26d552513b1fab01ac3304de7e2555c8f6a4e42ca08f90dd173b1f0238cfc9826c9d57203bd7dadbc288675aa8db2d9cd5e450f9af055bcb8f90469f9810c87c7cd531f613fc20bc2bb6fee3d38fea9d06de147a0a642bf3329902d687425d3c3b31cb7f3ede5d31d983bd39369ad143d3e7fa3b436242040a34f45913bc45295aac9d4800e391f73ebde1ef77a9ca9aba69ce3211ded109d0f77846017b5d9063b0f45e7151a0db26435bb7ee0e85baec604f5ce1ac61eb0a82", + "9173c92c8d8aed1334387c1aab9312bbfea3abdf3e739102c2282519d5d0ad6edaf797b205a5488c66588928b8ed5d67bd99a6e319847295471ac3f36aa357760422d8886507005eee9a6b72799e4ccdd776730c942032b86938c5a17146ef9cd93559e256d3426332e4331f9147c72d6d522b014573175cc725c13025b83a0996d09649548de5bc13589623226c6e6b159c14c43eda802a5c552a6699d77fb0891db76b8fbae0b30fdd554a86d822f7fea3b90a29cfb5dfd67464a65fffd44589568ae129a74d7abcd9b2465b3bc2a77257baf04f4dee10daf943755de12a5a4f3797db31dbaa4d1271e85bf7cc8a7816918ca8106fbfed18947b9bbf902e74", + "1bb23eeec3739ce7bc4035d8ec86d16da0cb781627942d02caddaaa4d4c064a5867a6f4642a6b5f4656838e38b362784d74811d9a45ec40d5dee5b719b682400ac28c60f5bbe190a7fb25ac9ed0b37e875c82b647d89838fcfc4d5aa78c47ae4cc12d4c212885b191060e662bcc4aff1f5aaaf69bba9b0cda9bc30855d32ed4587a44e1bf390360aa2ac921c595c83b7815e10c5ca3599a08931b601762d99b43c0b45ee19a1259fd8a1666a65e7facfeda3863d78f10d5003160084aeb06977142ed0fe80d0b1e49d2f67afbb0a7c384bffc982b6612634d0a323fd6d24f53835c64a30f2e51df10e64660c7cb4868c2c9d0873f81b1fd71bc1395bb338ee93", + "528a5ccb9b88bd7367ffa786b40384911a25128b55f416ddf850087697b916cb8890340d3d2d0be9a9ca26965dd85944c34e0a6cdbf0ca4ca15f905bfe7dfd763627f3aadc791e22cf31fc40f9db9b51e99b20a580e27353bad491e0d1d28d8ae4f78a1a7ddf7de396437573c5296fed0cde6985eca016c130a8f69f04b8aa1bde0bd95180bef8449852cda874a2a155fb92b00d189cc2ea0aa0973f73670e7dd9ee25052b3fd8a62678b81eee08b70fc06bb618d66bd949540fcbb96b65069c88bf27cc3ce20206c071e0736c6442948b49fc7ba53def1b0d057af6a766faf7604ab8e761fc7cd48f55f7d85299c5a215e69f2c70bccd5a2cd75ff6e44ae6f5", + "30b45f73e94728fa7761a41a4f598257461dba5fcc337c84a0de2df2373b602c5b680d406d314ba5885c13080c6f08fac4bc92bb4ea2100d7c70941a307e88e3a3623578d4656a8fcd0a5545db95554837083ad46d2a586502e0990055ff477f1883c0e0d2d212209848d96eb4910c644b2fe8ccfc3bd7cbd669c83d28b94c5a036fc3186e3aaa8d035dba72bbbf1a942ea868f1d28f0c46063a2db77b553fca6a18a5c8101f7373c4ddf7dc1bfaeb2513009ede37bc6310fe80f43976531975eebcb7d0aa861d9a1fbaa58423b84df98cd264f1f13a1f9e7d22b18b31c964e8460787d4f0df8f48ff4d52fdbf800b4c183ce39806d5c287564ee365caae37dc", + "84d6b8266762ad7b1501a06cbbcffa76bee73d20a52f59bda2da0a7b136b909366d6bcb6c73b846cafbfb320a467ae857a757ea5475234fd120fe8b50269d0c19c1af73dd8531ecb327d06cce89b6c7193a4fb0d4abbe78ff06ddef5b548c1828cc11a367a948f712103492bb3d0eccacb8b776422f315d1a08f51428b1769a494a6ed8740d197ff05c494086615c31fc250f3deeb60e4f8de417ac879616badbebcea523e5687052671ba1a66c0ef9f618e9ca3c73913b8dc98b97c826ddc524b0d143c011ae78203ee60a4026b5f3a6cb632b31f86ea6c865f8720e0cd8b66b804ad6df69fc5aa47ebe3f7ab79ca58dd15c237a80bc180742385640b5d8c6f", + "a0925ca3ac14060a517418354549fa17a007e35b2545e878eb0f614c809443da6124d25d3b568f30f3706b73043d7d86ad390717b89ae775ad44098133878a53f154a464df4baac7150d370721fcd1aa07cb15b5fbcf24999d4bca1b362966a4d92d23172bb41ca2cd2ef2f417937df8c4f04ca83045002aa6cd2124dcaf928033690810b4df987f52e277cc890bcfaa49a585a0568c00e995387e548748a2e97a4162ce40c0b4c2dba1af9d40f0b25bbfdb13ec5adbfc36f01099495e6897061bb738ab17aeedd35e4a42136aea269a2fee25d9058f2f3097d26fc6ca4e5256c5cae4f9e3eef66228eee17c289c57908c4e301d334ae7365d0d251dfd63dd45", + "272b2124ceacb53f600b19663eb70738ff9cd05f59701a3f5e8ca0e96df803c9d3ed1e357f31b3045ee930ab47518b4bb40ac9015de90e835dbd3def20c3e308297de35eb0d27b57aaa92978783c5028f8322db98363d03468f76c06786a5f2268a341c1e8a05b013a8702996f0ecb4fab45fb908588eaee9b2aa61e92a5e10c05ee2ede2f62ba2c9e8c40a6fe91a4ff7d2d9bb67d90c672971bdf9ab0f38517f55d717ed27f09cc136ab4c6cfafb5a400a9b5c4c9a271131d418a270c37d05a0f254a065d3ddaa36ced0562891a78117782ec5b510addd01b11d2982c47524f4c7e7f62578606141c08ba3253635c0cec2ceb6312bd4ddff69ba6f97a4b834a", + "4b266f822e3b3557538e33305db1e99a5f02b25d7c9abf9e8eabcd1ceb9da41073f3fb2e01debe61166d17c83d4687e3c1325576ecde3da008eaa7ab9b37146cb70349f3823f14785f42ef34d175c6677cf948218259a59596dd0244429c4ec2ecf691539e8ab09afc3107b63e50edc9220b38093f51acf421917b13ad7dfb7015182cf20d8e4c1d54da2d0b5359500ae97133a6ad1784fc79fc2c425d86945a7f0694e2283b69f3bf4c54f5c4055fd4f5fd83de4cbd53860a7adcd59bc6263892f3631bb9c8bcf685eb197e1c0e05f100bc6a78cb4dbd806c3ac6afdf9123312a8ae0c2dd078f98e6adec10b48b1c09e4fb0b2a55e16c02fe49282f249a2d5b", + "8a222d0a98c8954b6129dd86c4340dbe51140dda4fb45f20b85eb5237c84b32d357c05b8aa30aeae41d53c1741e503c888d37d628fa6d92a6a151198108723c95a3142535dc0a1f60c5a724e69eb148f7f2dbef7a00cd32bd887d9a0fe1691fcff72e35ea4cc404a3de8cadf905029ebf304113a583ce734d8908f993058534827f0e1ca31d9273ed243d03a031dc03c3acc337d2f0e45915f72a8de211b754f8b8ceb7435aba2d405b53ead8634c023f65e9f6c32c535a631a9ef8c5bff3a4bee69505becaad4121738baebd4fcfac37dcbe460e3fd5222db36f5010979543ee848f37fe28faec0ae3b9430df254e6b4eeb490469f855e59637c3ed63e5b05d", + "7615b80fd2daadce608ba44cba4d79278cdb891de329fad9f94cec7aaf26264afd4fad38ea8967a4d01fc425c1306cef3577add2de419fad154cd6fe255b2a0b83b2f996df1fc54ba44804d9e2298b7fc5f23137abddb3cb91575a1f51150a4531053eeada03bda86aefddcfa33f21f8cae382c514d781f2afb6f392d2041e82dcb94721504ee68434cdb55a2261ce51ec93027c0691094233c48b0da788190373b1221946383caf5d130709de287b226fe4ed6f3abe88b1e016f9f54a10644036fc5401cf7c2f9e5954e4d8748480d9f25cb6e685e37cec4d341373ad495d23f443fb4aa1a004da93c1497cb81208ae2125c96991bdae8fa427ff12c648c26c", + "22cfe1c5052e4d18b029ae6e4c24ca5288cde8169d1da495bcf0421f0bdbb33ca16d7dd94c6bdd393cef8714d081970c9a09eaded0aed481bb5dc33b71a4bbd40961d69eb148fde91e32d2ccba7260d5dc6f833074776f9d21c38b4546019d32c48ee9254b4b07893212973190ee95e7591d48ef56e4e1bc7d87f21882a685975d40d99eebbf6c814b4dc5fa57312501c33ff7abb3b686c5e5f7ddcd264da62314ebb74ff42bd7e123c44c0f14570f3c83dbc69740f530f1f35910eadf500b98b9ede8fab777d3fd367832361974087ad3c105391a85bc7c90b692919a57a8bf6f99163ca1f3acfcdeb021c047f74cff1ff8a50c7fcb15bfde3a92c0b03b4b68", + "685454d6a6cad6c7c4bc1aa4bb630f9f203267d45bf68f12333648caefcf0e8c26100d0742f2b2daeae26028a1963b3f2c4a44492b7954bf11227914d2589c7b222352d7daf870ef31c0f920e20be4d2baa0d6457413ada6b28f69bdbb4c7a2492963a575bf03ec7e7e4f8cae98d674cb868886a9ac54042c47018e19608e2419b7fd913bdcae1cebdd0efa9259183b000c070e22f9de366a3787d64e36206d53d492041ba702a688abc7f842531064d0066a129bddc2f438c46851abada7ee14a78240ba283be479c6eb9737795171e10a04efd9f9f3a4386e33ed3b1e3d0bf08f2abafcc3b6c843621246df13db2fc94c0239f9f342474ff7fdb45ff2cb156", + "92b7f07941964925d43e3689d70db8da390de3b2c8aced5c3a2f91509cfed7a9e1febae038e6c1e07fd7ab6f6a6703f9a2f7a026b02564348b1c8a808e434a1cf1db2dc4f0bdae8943116801ba505e26c900068d6c8ffa1ba8ebab459fb3b19fc433939aba9e50a3fe46b201a9237ac4c0fc17f43fbcbee31964004fefa34b022670493af91bbe27f08875ba01532d9815f6cdd75ad4c785a34b8e53843f98a2428190421056581f8458b1d0c278036270c84590beb05f252ff52eb27454140d333b20deedccb0fae1e4560f2c9088467c994b1a5ae8f5dfe5e150560be6ee5192930a5a91b38965451df15136d12a7a0260c030dcf9ec2b683c90a3e4220d36", + "735d661a86d0ad7d55aa977c7da9f41ebad483323896646a119a5afadaf238d3a3d804ad4d0baa503a8eaab768061ff2aea7634a9d5f2c8ac448e4ae68b8e3483610874f0cc4526131a7cc8ac94bdc02e00a5eabd743f61cb2473c52fc376ad087da79dc9478135ea85166bf6ec12c123217408437b8c331cb13c1f2763c08c87faa58ecb1aa644adeffd0948d642bf46db411fc28745ad1b479f70aafb9e22033cbead4a3543ab80f103b4927c88d573e7e94b6ecec3fdf146342e8e5201714cc5c7fdeb023eb0357f59033cf7585a1683bf982c0b757b755f78720aaffaafa4af241623201c477bbb23a1fc234b01ad20dc7f3a1126e872020c8e643ebcc4f", + "19b37378863e8e2a3b7b5c72d619ff933ba6ca94b1e82cc681ce9e71e458831ce14d537729e7042e6cbcf62c84bb9903115d0023ec6089008c151f0e3d69158b51b1324edd99f4ccba3a40864b128b55fc9948284b5a1f2120d60682f352284a0518c41b6a29a09180165d1b99bb72a673c5ce9b05d2c3d7b137b5905d1d3e3b771ca71d2515198a08ce2b9609f29f61f5ca44ea25cf532976ecc38e61ba8633e21bc1c111d3cc61c1fab4167a65f4bea5d2e89485bc743ac48d68cfc79521488e0c00bf69bd72eba99093d6f1cafb21c8528ca4ae47b579f346cc37914d6f7c051202e9fb312c728133b190f32221054979d157577216f5ac2f2d99fd74a8a", + "7937a399c93062bf7e8ea3402441189fd04feeb2788df0f0d3133b2e79261e9de8e098416f5ead7069c6c22150a275b36df45d95d17a23d1ce1af2b1d3f963682e377d5f50018f0a4ba1ebb059a5da9903fb27e19191ea3009e2378340fc427f028d74fea010ed136dd5710831af92b3838562fb480b29b32718ba31ce013ae80a5f7955154520d74d270a972cf6bb29f847391b249b44021580e128e7b146f2d78a87a855a1d7511f01b5efc7b79bdbae621d6e2e120363a2ba41d41b1d31ea6d599a64c5f60edea6c454daf34cc0df56dff6325c595b0fb82d4d5c525f12555dcf0e515e5d636cc8a787695c6ef7517940ec2e22fd1747aefc7c6be1b8cf5a", + "5e33d2152f7322f870bc838c6987ace5128c64a5389197bad892fcaafb2e9d62f3dcdab85338cdbd0c1af83c2348ef91d0db05c53eb6d45e015a7e4ddb5dc8d4d3f3f1212afbad8e964f8bb53ee4d7f6cac871e3dc740c6a6966d5ee92933afe9cb0a6f21fe46780f9f6d00ee13f36349b7eebca84705b2d82e4d389d1207c065f178f908e23c299fb2928b20bf49ddb61af563a9b86ac10101c46a2d49247f819ce0627f263d5c5d61a77bb6c185423f6ef8c7da6d3c98f40007054718768ee2785d124545911654214aeea16b1680ae4e91f4436cd3cf85b3703585f6dd24d261b4a6d53d6ed7eca15cee1f305e937011f2acabed930c8395f8790586f4424", + "492fd0ab61d60d43793a05068dd3ed2d64d822fda4a408cdfb63913527e4866288bd94852b19cd0105f9ec8b769e61f2b4dc85e55991e88620b076654ec898f5651b86aa907dac6a01435d6155d21627972d487bf8c4756441dcdf0b924ba95c0399ff45af976d3208a538f28ee732816485e0a11e5fd3b9a36a6d1f25518048b130ebc4294a3e80dcb474cf3fcbb6c372886b35524c6a63585c40639da24928eb2db3dfca312ac4fd177654909e458dc0e7a33f3087de5f02b01dfa2babe7e209111ac7caf476ae6ce6eec7f0ec8a8d261f1b9be37b8fb33662ea020bfce889cd89d51b615264381d48eda4b276d8f65f5b59a89cdd139cf52316f57135fe28", + "7b3a9a9386463d138a0c9d81255d584cc5ce34700be156805bd8fd3a1995c34dbcba82e7273c44ce9177a7782dc81842e50de9d53d352c64aa22d598ae3515c86004ba66e2fb9fcfb40d2a474ae9080f847b44d75561ef7da4f9008789746aedbaca05c4395e3745991e40656f15dc75363f60bda577bb670ff9b322b84fe6dab267cb916861867e35d899b0f5852ff9b4b5c4c8c636b08d2b6faa9022d75bbd3d357c48b620c46f8fc32c6236de8b58abf63787ba9f7a40f7c5fe511ef42396cf4939c963bcd52264ab085c430946e0ba7dea6ff7f023d0c4c537cbd5d355f05f37f7dc924408098b184a8f8afdea0c11d5776b3ccb0952349e046847a215c", + "2423df810737ed04c2c05c2f49be3b05b07bb7d122b5a50d96ae2a908bf026f12235a9c48ae5196739bf5a5a0f2017038eebf7bafbf07c7298b009762bd3daed8bf2b640bb2bd4bc2d00090b35863b95a39020d4b8ce4e4b4fbc34f3f1343e30801e6b2b3488b5e5352f0bb87150aa6b14bf76b759ef48e8acdf231b4f2a60f466573589434503ccb15f43740cbfea1d2d37d4ac359dcfa405604476963c685c534792de48fc0d114de028a8b356b6c54b2a88832f9cba2424470e88ba9fb3ee61c039cf5daba186593214d3bebf292efccf251d68725b905d150a42699f60dc70632a7f9b8d89f1ffd8ff1610b10552d89dbe620fa77f77bc2c1da4853167bb", + "6bb883a99de7a9d732fbc71ba19aaeb7521816c712b11e4e43af4ad2f201fd38e804f227fb9c193def3eb8d8a9a16c34f3b104f2d94fddf0c1ee3b3fb297f396184dd5ecd1116f7ab042d813312f45a232f40b74dfad2f15c41d6be7e73bf02b2ea94f8c0235042be41a0dbad396a5c217b168337ebefb27ab2abc046047d70767b164b489c87c30ae7ea41fad5e2e8af97a396365c09f1ceabc1291d61f95794023b34a69ec92968943b740a7b62fdf29b0de6db2139e304b407beae8c91fc9d92c4030c6151df8d6005e09af647ec79ee96cdf2d89524cd40be2fdb4484ccf0fab4e82341d6113d68ec0aefe3c08a8fd4736a749041448eb40d45cd794f1ca", + "9cba63661788a15d3cbf51a40e52e2687144ec82e83127a0e6c1c3cc44445a2fbd5401c21527d8b4e2a219b24acdd15b9df5b337b1eb0928477fb7f58f7a23f2c3076f8f96614cbfd9d03126b503cf03bf689b5f39094da54f9c9ba44b07f22af95b8f1485ba70af4b51fea61f45956921b982f66a0efa8b06657785b4fad81d98bcb882ee9543de4efec5274413c2992f663a40ab628883b4cfc9697599e1d098c96b106caef9848797fafa15d246e9d2435d204dc8d357d773cb1f68f0e78b4fc4beacf069e17dd04372a57112fa8f59616ff8fcbfb3e0f0355ec7aaede199fd0e93c38f32a85ff4473ca047ade2e265ebe07c5e0b711130985f22cbb04d36", + "7e034766252cc2a18573275acc096e8cacf6864c96bfaf86bc9dd2f9039266438a9a43530646380c59b26c67f01a6cc9331e4471c328fde16d4bdd785e2b5d0e73aba916145d851f25651f8aebec14c8ee818d264b6fb4fb45bcf42c052a6920a4ec86de2fe1a0b2bbd34f1af4dfda3bbd5a4b2f727e9f86e4cb5c0fd137433504a97bc9abd28568f413f557f368e48a9cf0e2cd75bea2259a9fea103fe920fdf7dc34ea04cbda4920a398d17188d883d0cba0c06e8548bc92495a1e131e44f6d2b3f2175c3ef80885528e7579495ada7441129015ad58c56ee8721b22026a331d801acbd0cc72838cadfb5075c6c9afbfabec6a58bd4158ad063af83e69f118" + ], + "z": [ + "7b096a87d2f8fc485175ad5719f7746c44ed1d677b287a4c71d84d093c27e1731cbd6037050afdb20117c1a38aefbdb70d994d5964cdf1ec352d2b78b9f0b32aa5645fbed91cd96eba92a1c1451cc518e04e676a87ff228bbeedfd0e4eb6d301e5db2997cb9ac41680861930cf1977b242762ca7276fad3ef3a87e724a65bd9f04ee7303d7461f946756a8b5fea8e6d1ba49335722f17b2f071b1ee5439ab1a8e7a6a01bb8856251672765b6049f113e79bce3c9d099986e326f026ce97815f3833869223a0a655810900a55f35057626f2beacde4f4be52aa466909c1a91ff978c3ed5193592d0ba8954ea9271901f4450626f48d944cc656d75bb248cdeb4f", + "951c493c84761405ffb36b92b3c6e622480b86dd666070e99e4b681830b4c67b793c5b0d43154de4c048c8a6d8c2a18ae98b8ce1daf6b04d9e903a10fa6dd1664f98a569ff2c8ee7c445fca8f71fd5f836440d290bcfb1551d6ea8e8353deaee06e2f80d30aa0953192ac4f9fba1a7cca6c1023341504452b8cac69c8429ee18f2788a828f827649795bb9f00795af0dff8228f5f3b271617c56abeada8a266faf718afc4312a0034ae7d15cb96c5b9b9059b243a95eed6e1491441d5fdc41400e7fcf9c462dd0cb0d9233ebc4a927f1fb59536bd7c21b569c12e3baa249216102f5c18b5c13526ddb88529ee0b0df7ab54406a5d5b7ee95f799de2f842770a", + "268a869b40cef0c339a39df9a903962e66c1719fe172c25e33d16068d35fd32dcbafd8c680dd2b8e1cc8a98916d692823dcb9cdeda7133a33017f8e3546bc1095285c97579e3cf87fabc6230cdd70f7ffcdb5e0b24bc72c3ae5c0d53c7c38baa4ee8276b90d402b79042a20372c9ee02c811d0a709134264ff0b34b64986d21a06cee299525b3516857d2f6e3f4ff0b253264e4f16cad06f401ebd1b6eca62734ce7ce21df23278e03a34c55401c6b5449c64c2da3e55802613dbea2dd4a02de6e40610357d9e5d1919cc0b2109c45b6132fcb1f8a3ffe88060cfb905b395a85dc4d6d10addeba74cc63975031e5ea2fad96f00429b211bbb29ffeaf0df596e6", + "72712e7a3543a5fab4fe3498f123f74eb816d9ad6908f1b71e82da4a350011d23222aa6d9f2d06f391cadcc235159e0a5c682bc7dac21d1418455938d989b8ab7a0bc522bf0958b944740b161d8c5923c2538cbf7b7c5edb247d1a716c6d6496e70fed21ca53b78cea24aea70413c4f95c8679713ccd2750c284b8068f471151dffa38e1ad678ea45ae5c38bbd9ba143f3b9b5fe9f19fd64f4d3c43a0f6baa230b776092bc475bb6fa04bbeeb10421a294f831e03205b84688f42433e1526f8b5f66866ca431cb76fab4b228b2537307ac454016786347f0e82fde21e7444be053cbbcff369059df9c4330b907fd93877cffc9fa991be1c0ba5a2cfc8e97cb35", + "5352dd90d71d14fec500769aab74ba45371571f3996dca36db969011e1bd617c5f2905a2355308f9c6196824eb0751946980b9ba8202639d07a38a77cf0f2714de816463f1f0b7bbc4013ee92a839b39ffbf8cfdaae4200bb9ddf53c216b7c94a0c762969f259e7e22e4c6a3445c7615a9fdd8168b7bd7e2d3323cf26da5619346b11021bef5fd93239c8fedc1c0d00645d10a0960e61b8cad018b74cbc4f2ff8201ee071b1a2e77d9ee1c5705516b7ac62b0475fdb14a79b5551aeb4e81a1767bb9607800f9b26117c4f1c12cac20b0426e0071a4ecf35ec1c9f81ce0a4aaa662194c766d062521bedaaf0ee381ce60224f0ca771b151e962e23447a08e3e00", + "1937d2456e97bdbd2ad30f7fae272ee17a8b1e589d0fece30f9d6f9ff5942142a6a441a739230964a24b435db892a0bc932d37e8f24a9f2342868083d65d38e76382c3cc0ee5ab437ee47e8b7bb6a613a67f76691af9ee76eb5204cd2816ff00035d10fb99017499576c9bac4360be61abd11a3c1f8953f2de5cfb3db0b7ec63477a4558a5b302c2b766181e858d34013b5dfa185a49184d4b99afe3331b09df2b95141d04003f91d5f9f8b80fe55f048e976079e7cf6fc69addf96a7d3f94042a64fa5bf653513d4ec128ff771d4684681c78473afb3ccd57cea947f5e0c24604ba20b2fd43cb346ca95eddbf4ea77f2fa2602b895570a02cb7d1e6c7afdd2e", + "666d9be052867b0d97f20dd6e03d238adcb87c46a8331e6ddedf0dd311dac883391649f6e84aa6fcb0ba0b8817276428d8b549628717d0c5be7d4e073be7eee512221e60ded54f25713e5692a877481f3d3fd243ecf8d7e2fcda8105cfbb46201bb4e1be16ec5b6e9a8cf72731f3c04a9edb050e4461bd0e1085256103d8caf88a680c3fe77e570feaff1fe5152f9be3df0158ce351898b77d96b708ce77f3d7923989ba8f61900ad5933b3c3963d2feaf0dbc3eb54d1e36344e4a411aaca9083c45305af7b5bfbe5d16f906bdb47af071ebc8a6430bb98cc619ff1bec34cdc982fa829087cbb6ee4aceea46b346272c4240c7fbd660d4fdfa79bedf674dc4b5", + "48fb7208811bb70dc9ed1888dcc4e0a16b4e2d740eeff36046cd8de4a7a5d5ebc3807565848b39d6dadaddf09f91ab2dbd9213b59f80099e511c02287f1d1e3cf704695c812b52b006e8d559ea6431f2fcb29387e6671b6e84b4dd90b4c0376f62aa2f143f43078f08a04e359201f0eaa38874c6e65c9a0cba157a8eea4f761428d87976ce1db784c945e48edfd14d33db38f94621394fefa46da6bfbecd29bae76643e302531bf36bd76231cdc77734067ebf0db9a0934fd4bae4685499f4d8ffdb22d394cd0d833a20e7a48c47e923b63b883945829722051e1113415f2f9b81e50620abd8f79abb20ee54890faf9ea0dcd07e70d55e863dffe6a4c7b7ce22", + "4402929810d8ce24582bd8d1b55358c7a3b484a0c18841b76183d867e3366e80c803acb4dc105ab5e5515406ba4c0fb6b107b6056ecda4d8d7146ca9ffa9c175a69e84e20ba9018b5da3ef5bf2971ef1240deb331dae138bfa9ffc6d3948e3c370bf78acb59abee3a48e90a2f91954e80f65811e0a48898a158f6184070e223c88239118ddf93c507ed4c67d33014f20f2147c2ce89a191ad576af527af206becf0fa204a5933082d9d65edc06e371d1e91215fbffcb6d53a0302db46e551f5a9a2f6c9bba01d46efe4164a5580f1c7704a9ea3891d438fc0198c3538052d6cd2f823314150b18b3c564e05090bd40400a34d6f4dee69e964496b95d1ac29456", + "277a835927de593681f71c28a96b9daa5d8fc313e87f65f348369a2b8621650d7b6c1664a0f451cb7e902890d34428846c1cc2b6ba093a163904b570f1e93141d783cef4c1d26504a3532ceb3827481f8591c45ba01e7e849651e0478019b7d9635b9a1293a7e98a33401deddcf07545961899c0a7c14c79aada03318ad5c24f7b9a20ed8b8409eaf6d55c587620d06f3fcad971393234de253f964cf09af13e479466e67bd4f2d8e1df02c3c85293bdaa09d09e9beafdf5af5c3d6be5ffc4aab10c0a45ecd36182dcfc6a3869827aa05a90f4dcae8b6d7e32b7af1c3bfc43d6312d5f5019e5afe06b398c66f42a15bc8222f7de094a4e6a18dcfd2189026585", + "2badf34de98ed216fae7822411999526cb314ac2771e9f3cf37c0ab4db85d685e22b0b3ef38fdab0d3f7e949568acc09eb5d58cf5f548dd9e7f013b609b7e3e51ecd58af99749e12c89d2f52d82bbbb2f609b807da346a1dcc4f30e56033e70f084a5d1bd854586cb93e26525f27427e012b99f4c2b708944d06a5a848503ba74579926c209fcfcb28bd28019581cb5c8e1b41543ab2476698e4531c64761cc611f1676b3a4a5845e2d1ae216332d3df99a196c5911a15e8aa2941290aaa8274c649ed5ab292ea971afbd506157ae336077599e0dddd0dcd27a9bfcbb529d92fda5545b490bdf751f7d346bcf6b2b23ca4a1d6bf091033f81aa347054f1914c1", + "922def4108c85daa00cf29cf225c7b51ca40d9545c9c25c6d915c92a682d5678efaa6d1b8653f59a2c105d658fbab7818714d7fba9096fc2c8863536715246e0b338bd97d0447e892f1d38dfc3527b00d95f4e1f5524efe9d110e4788e1ff0dbc8cb2b6abe4b819822ea46fc66ae8b9da8c607120b10f171f3914daffa24b92e04de0a10e4f7c17ea3dd35dbfbaef2dc13cfeb9c5562bcb3c85e3c9235021912e39548e36ff6cd784c8d4b18272619a80b41aa7af032086e6c305b8c2ef90c02e78ec917bd5519234f9d5c2d1a137b02447bdce577e0e407a6d9d3e3976df69fad8cca8e97989cca2ab982e5b62d37bd5aeff2812da3a7fb48dabd1902f4a9d6", + "a444c5d80d15d4bf62b96718ea9867aade2992aed6453d332a45296f014fc0dd51415f6c9053143aed1861c2a7590f0482aa0dbb905529b133272c7e0fcbe328e36b5510ecff48a871eda9c50154c997673a87d1663984f08e09c05ea8849dc84b9a2630646e4c4f80b2232fdcbc6d0bfe9a94172541bdcdd329fb33a841d6974b58b28f6cdc313cca0e8a32b05fc096bb1c83d0684bf22d90071ca3abbaa135c8b2a3ad69c0d152b0b933d7ef096d33b7f6d63debdd3d609e4ddf22118d28c496cdfd74923dd991a4c9b44a28609951122e7c8c768878c9c079d1df362f6eb9d678ae4dc457dfde78ce4f281ef4a17e975b294f54ac496767b72e07b9be1844", + "727de2f7d41f93f793ee33baa5a7c4aa19f550a9bd9f8e96494415028b5da8b484bf4cadfa8ed8bbbb613b3e5b4d8a11c25e21cb16f2ba5ef9f2d69f3fc335eb0a099eab6524775252f326b306b2325329b694984085eb1cdbb2e1e01b81d52a8c08b0f3988b7f042606ea9aec6fa40682dff6cf98c7cf71b9224b418158b5252551cdde497277c2582a3ed80488b6dd108a0e5c5417964dce93a40047025ac980aacb8d2c1e717f3d3ce94d8296ca3a9352da33b37edd19ed413807dcd004f7582bb99ac53db34727f803e409baeda72e3f6e38be42c60cbcebbb79b51d8bef25117e0be7ca31f83dd04f3d0aaebd97fac1a34d7d78ea6cc6ad731732e9461a", + "3c7e01efe3954445bb26a35fff8e711b5bd46c0152de0f6336f0b223c6d5d6d5795ee6bfd02f764928b7174edd2600d6e0d1d65f19873fe0f5c990d7a748c6159fa24f542ad74460eb2268de27023221bb592171224286f20a36157d1ffe4855897c95b7aea3907d1318ea701453ffb96383c31266d96dd983288d1277e3ecdf799dea90f226619544ad0ed28e6c8e2374d5d8f5a78d20739fc57b41c125b34ed4740ffc96d3469f37f4bfced6a1d5eed48335f6fbd4ea943ddf72b07293551d654ff536fd08d671af8d9940867226a21bfa02df93aade42460ac3084342c25c26e8914c9b2a00f61286034e11ed6c0923533cee2e8b20ed6760388f89697023", + "433f0a36ef55a278f4f1a968031f01cfb6c4e903104f983fc50142bc414410c8abf8ad903fb22576a7558d90e339c5204392073296f01ccbe8f3351f616cf5713e20a5331efa258ff9ec434c134bfaafcc2f48214711d13f0cf5bd3c09d99d2b1cccd54ad5bbd05332c6aee189f4057fb65acf824c3cfaa73c57a41584b20fc568dadbf5b85add3e837f81ec50928c5c273c609a78e31bb53d6f7275f965afdba46ad037c2c587d43451a577b1e412218e5f12704e223945bd7a98411972d2f053bb0d82622e125228827c494f6b9579be833bb01114226d026e2a7eca348e1c026b8aaa0bb5b802a4a77f4afb00c11ba4aee6ebb40748173efacc4a63269928", + "1602daa5fa0121793f3af0837a6108026c0dccb84119e40239f04937e14f07b0b59e1aeb5f4280d34c2680a1f414c76627083c120ec240ffab782afd1d7eaffa46035cfefea763392e80dc17b7c5cd5ec747c805eda9ea1fcb8ce9e774a8277a46a66b627f13bb57d22d9020406d485d1badd0da134e86880a8317eb03e6b2ab1e0cbf18d83b425324a95af1de9f5284345e5ed6478f20335835321643889fa0f9ebf25983483fb6f20a99bdf7f592996609fde59467d3aed03d2edd85f2af073e3abafc70943a38b5664a9140940659a01f6367cdd4add3d0c63e959ff95f88779facb40cdc9d2db7ddd327e20a50f082229e563d847053911f8556b5de7b6a", + "20b2e01f4e2b39c6058fcbd2d84fa7b007a227602f64937b660fc87e62742c0c2f0f19e21bb23d43e010e5ba4b60f9d8c72564adc3de95c3db8e85110df5dd5ff0049c73ab6785b8c27b57c7e03edb55dd09b178d1a879932609abd754a173c42b31e0489e91b731dd441ac1ebc6bf43bb495447c011b98f833147c674555db18914b26497fbee1bd108873cac2534eb05a19143d06601b43882a00e0ad8dbe2b727350430b26ad39f531ccccaac14f638873903774a89a0d070481755fc529199b2f68030203d39358f70e6f3e974573840a0851bb1cc9d1c6f155e99a526dee372e5f08748ce2e49a83fce5928f89fe321672aa3bc3bec453ce3ec683ce99a", + "329e76db6177898b2104f401041d11d28a58f4f81b95810b45626f09695922d1725d4232147094d0b84ddca6d32fee121fdd8b1609d2fdc3e3930f97bba8fc12aa57eb48a8a1daef93fc9a4c4d7f326d4edb446254f2724d83858e932811c5fc151deb1e2c7813e95bcdb938cc996c840917908050606066259a44113e8fdeb8563ea384a2044f862ac934ba5f430fc65749105dcf9ff359596a22e512986061c22af52a2a186c073995d81da2183b3f7f9c37fd929a451cee21756a263eb83f6938db24353c067be42ecf00af57b1fa3bff3e2271173273c8a269fa9cc9c4097a365773db38463a5712869cc7777db25cece1fd220e7cc9b16b893b16f9522f", + "a4bac2955ec415198c90a92f2ad3570374b0553fe07287dd5fdc42398a50a8a4891a306304048d3d926ca7a3074ac1b20c66f8e9e0e5b3eae2c554c4cef74a16c9eb95b04f9494d05d6997eff9edd3312eb07db91e4bb848a880cdb8e1f289bb153de4eabda13e02e47aedf1dc4909278a62c583d033b353425ce1e8d6e6e3e59d336eb7ad300e5666c1a8fe65ad5def9f3fa3e90a09a5c519ebb8e239d784e5828a1cd1baec8b458bbb57afc1c29f8d48b52cf57c64236e3af0c21c283f71df3c5fe9ead00ef51c19c41e47e7566aa7fea5639b9954ed1eba405b453b681ac479484ee971c6825703bdcad70154e825ced685ad9da72026109ed62d15d3ce", + "a39da1381c74dc3be448540eb11f7b8459ba4f8018d5e240403f82dc25382d9d55c13c46e7c2e19e55a0e0663d9eed0159e920dad37b7e036461f5b9a9f3abf09f4bdbfdfc314f66ffaafb2fe15c7b69242e8ba9625d153214a8f4289189e5586dacbea034832e836d00bdb13a975525027e2d846998c472a7a18bcafa8194079959d4f942011d25f6912b6f7ce349accfc2ae5b00655b9f3dc1e2da7fe6a65adb5b269bd530e81dc94325a06944733e2d834a64492f4130b805f95582d9c112e5528b55afbad85e6d97c458aebe314e1b5d70233d3cfbf345ebf0c2f5fce788237323ba3ab4aa3922954a739503e157cedb3d52cfd0d8d94ed2fed82db59754", + "4827f2d9ac7e1636e62d13d9e2bdd9f3bb683055fe5b4884ecfdcb155387989289b814c10aebe4f0a537d5eded377333b83af12709cc7b5c44d58eb89303bbc9f13c75a2bda7af8fcfeb8d78932e44e3283aa3d7f10e6aea8e53bca275ed781bbb0c0d3f07c5c745cf055d1761548f8018621211d4d02ea0360eef04ac223e8804c61f7a00a24b7af6b0eba448645a83f60644a6ecc9966acfa251b43e75b0b1b5340335da4ad6be3b957b9e59eec05b9da03680410b7353c2345b78b255c1fa99b40c72e53d6bc8fbf62d0f86a6519495d5a960e1c187a4483efb087faa598cb1ac37f1dc562dca526d9739cbdffb51f8080df4bd098fd3d867bd26b95a368e", + "638cf722a7b52c5d732c84201d815a60c1c0c71c38215b3dad9ced380c1493a4da30d4ea009dd00a19742dec6e0c8056b69ada37389ae1540bc7a2fc28c07718b5be2384fac7ff001f4a38f269b2eb869d8d5d7b7343849a4351c489358000d006fb2c378d680eee3e367ebf02ea81444014d33ce16ef1beda4ad34fb95dcaeb0791055e703fb49ef94826db3cb03d231c284b5287bb4f6b01dedb044bec16b04049d382b96063db6fe2b6cf9848a94d2038a0f4a13343ecb405f8f7baf87e449dfd0b4988878ebecf89a745c387f0202aee2c93dcd77b68004c6aaed9cf921cdd95e60e0de3f94a2b7f609182d79183645a825e61b3be3e81d7dfd4202f28a4", + "71324be730f8b029b7128f5226367a950ff526b585fac8e1d6b6820ce64e9cb6413710cc3ae1c89e9b3816d7cb0f726ca9ea3d8bbf83dda3c8d2a40cbe49a68b475986ea1841a66d31972a218f57d4c0b1206fb701aefb86de705184b5e718bd0eefa355d42825ef02346c56dbb923126c4542898bb091dfac1fb23ef7b8bac4c8c582e7bf54f893b83c515cc25dabb48b99ce59523301679b6cc2a7f849d7e8732603089ad2729c849ed570abb5b5cf303488bb91acecb270269bb15c18391613dee826138634b7c403644f04127cb3d5440cad6470f8f0e606a87521ce6e3ededefe0001660f3c3f2ba9909b183f474feb562024a154429f7f0faee71393b6", + "6b3ca2bcd8ad8583a2d7f7ee21f75b284a0b8de55fa6d935249285e25bcace20079756cab802b98e3b63a68c8d0559945ac3b8ea8cd3ef38a10ab21634bd99d627032572739ecc6dd8abbd55cce121b482e9e33a374007707232974f8fd62e1d0adb45243ff023f01fdd887a4411bd48d15f8e85b2df406eb7eccd11cd97c679542e191b7b8a12dfcdef12203326615187eeffd955fe424dcecbaccffd816deac3a99a20bd9ada3ed48b296b9abd6a3fe241d709499729163eda2f99eb7793e58c33bc9f9efef263805386cf0edae0a77c5ec850059d7b807fe336f6f09c447ea62be098539ecf758f41b0e15638491a494ab4267d9bb608ddb630db2e220b9e", + "ae726ca556da62b6a121962c65613ecb47bae786f4bdd1285dba7b40064fd14b7f1f613d73d1c27955e5dd51b15888ae1cb828892ffa2d0d6faff5c42d53af56a390da4cad2c2fce939e55e64ae9769fbc27f3acae1a32aefe873268c48e3c95bb9fca17896f9721fb6ebeabbb7a54d2ee3449efe03167af9193afd0992e84e8a4e5f5c4da744da4f5950d405cfe41e46955907cd5041681751e1bc9760ac334ac2c03204a89eef0a8fc6547794bd9a08a90c69ffdec3e6c48313238d811ce80c4e9df36d8706c18897f29d60e73b8941b79a6da89abd4f9ca54f067e61de1cab39896f47ce722573fb36b3168fa5bd33e0eb4a158f59259f6ab0c4824c4aa4", + "4b53a292db7ff55c1d0fe2e083ccd742fe702d26564e3bca67a9ab834529e0759387ce6bb002163cbadb0eae652dacef02392b6c759521dd80eb21afe553f3b66dd5694da7bc59c4d42a8be8f4be6e82a830b5b74671d88952b22c8e02c13bedea5194bfcdebde83e44ae75bc8ee975de9b67c6bde426dc36841131a8c910ffc03a50e4db0b347f44499ec70ee98afa932d2472fa068c904d20ec38c7b7c7483270c244e7c57f0a712810f547f9d1f33e4131f4143f25ae0a63111939e6fa66d9650e7e64b43e2069c4034fd4c7bc50a780693cc7ba9153b323339e816ae4d54b9b03885267570d3867ec94aed5df74940efa775edf4b6fd981b6fe2c15ba1b3", + "98e617d7a22cba757d2d57edfd3d08991736d7cc5efa6dd25a0ae45c9ff28ca41f269d214401994801f0f75d8d3f766ad4f0194dd98cb338b5057587856b104b0f6c5904f0c766de4a827d52fa56965a79b707bcb9d7f9b44e827b85e05834d4ddcd0ba2746d7d03603bc775e93ac643d895583473ae199be9ddcf44427307baf7f98491703d711f6ded2fafef5d4538143601a1c2e676e040e777087e8ba73d34734b18864e1287f677e9ad09aa3a7390c433349c60e765eec23a4f7352664ba5b0e02f8ce1e3c2cdc1c43215eb12d5c5422ba87f5bff2160a01c907b0585abc59a034b68bfaf9911cc5645fde99158763b92e386515f3887ee86b9169d7bff", + "5823964e915e5c95e4c5fbc180fd6c695d9ec7348746f2999e942fd69b051d7bf68ec86384313f2e81deb4e9bcf3f79b7ef852d2eeba61de83ae045ea19b1a913ffbb828e0ee2dbd9ac0ebdebc8fbe3b6671176601d70815dad8b1e2e8c800176a1462a54e6b199e81119f509c0b94eb3c209a04f2945da57ca1cf1fc4fddaa79b1ba5985598d176f4d7b9a6766a49ad212ec98f16b943b185a14c5e514be4cac3417ed410752b06fe57ed03499622bcdcd0a8d2b805928135f5b75c2a652347f4abf6731657adcca6e9a401754bfb984b0ae96cef1a24e5a98fed097295517822124a161f1b051d35d8679a71112091fa6318d02be100325564501e65fac", + "4d2f84120ab7bc599218f2c6b6d6d427a004844fcdc680f1221c9ef49bfe32ff741f713b97e279c5eab6d14034804a73608f3c44d89e6856081114ce0f9585afc41e937ad6fa4c715c10e0138db6d3d065bbeaa520945636be9430eac8c078cb9d9e1c12dc3fefbfdbbc4e72ada35c2da4f62ff28b9d469cd569e551364811819ee5c4e060d48e45195ab32d607c89297adcaff286191d7ad1c500d1b9d6ef67a02e7f0969edbc91a3f7d83c0f4f649f7f9a95b3e673c09a124f935d2e0ee03f364dc3cb0f71ce07809ae43008784968fcde5091b975caaf269181863ed2a16581a224a9808f1e67240a4d575724fb57ef773e2931793d7ddee60751adf7b4d0", + "73466255075e0a4fa59b600904b8318b14d85577592a84f5db5f8dd146d260d9898a6221ad9917f577c69596da233cea64d47c37c328c34f217919f5d08180dbf989684688641fb73bbb57d15969dcde3d1f99312784f1b3a1965b8a4cdfae8845f26dd39281b179f1f68acdcffb8155d7772f40ac29b35428f1948b0649347c5a6a523ab8fe7b8e75eaf439c3ed38d3f82c4538525b326a09a2db10c55073692830f43a589fd7232bad1f6dbd0a02b3e1cc0ad1de93eae570272be497e482794b1d11a4e5870a81161ccda9b714aa2013d4d4e25a1a1a4649482c539be5023820c714b4692191924ce4dc6ffa45339c5a42a983bac663ab38861240f709cc6e", + "a8fd113bb4c0e6e9439a939d29e845d7ad6c387e6d0aaa9408ec787818a8cd0e403b5931f5d91faf77501326996219417f722abfff2621d4eb7ef79eb662ae0bb00d28c42e22e1ca3083805a2f0938508c48322ea7f86cdb7538b123cc35e5c788344315cf7ded91ce2196817dcbbe1476256da99eeda3d18700afcc7cbca0c7c29319737a90857f7bf1d9056fa6b80f8c64f1cee503ad667b852c196bb25a39e46cb684471cc453be7338388b42f791618e7c0b771305efae230f2c70c2f40926eb0ad4053dde718103bfe2e621bbb3b8b0e28aeb683deaa2a1e1b1ecf623756cb81542178401f657b367dba3e98c8f0cc3d5aeed57187828deac6a6ced4125", + "184623966e776a60877e1a3120dd72963fb523286b199d2a142a30ae4dd91fb01d943fe1b8024e5b5f6f7bbe8fb11059b7ab1c9da692a189b0743de9d3796396a7c658adf407fa3ac02bbf12288b8883b11d796cbaccba0734af08f1a51d81bc9f11bba4f839c73ca6db24dd6a6e07bc176fe2d8a37dbe2705bae3160f5917eb01fa564899f72873e356e9c81f6502a2afc22630dc16da248df8ff8612580448b7d1774ff4835ba4c6e2d0eb6bc2a8b2ed9fd1b7922b7f7f608c85cb6ecc76e44583a9f505092b66957c959142288858b3807693f0657906929196665959a1610ae5db5d78637fcb94b36acc86ec2f840301a072587056b4df5ab9fbe48d461b", + "98b2792da6626b649aae1d5950e1ca2f0fb0ddd128ce992fff53868d44178046ace281a8504b1a5c2e46f3d6433d8c0b85a81ec1e949db896c3e9249f1d631a0d992da925be46800fd85a9b7bf9bf263a03ad8e345953e657c7b5212cb45be768e52d7ba375615d659ec8ce8eac54ff008d859c813c8a96c7964bffb3be07787cec29736880a180c8dad81e95a4daa132e5e1105d46fbec33ee2f0a90c45218c51f38510fb69e3ab726b5a8637c637728102540c4529e6d34543b47b81fe60211f0f6bafa9fc2c16f30efb858b4fa6aeed7b127da4c3cf5e52f7a38acd71de42bd5ef8c4d30d4b5f54b48f78d1befe2a1bcfb9b9316c6b5de189f5628b84771d", + "a1aeacb2817a0ea4eac32c19a55f7567d9462bd36a33e11cc9053cb1f65f72db68194f667e4dc27aed26d3355e54269202d0e4dee81dc7e0454287570bdec56f37f360b24c202b333e253f086b7780eb39e99094f194b6df77709e1a6af9928fc89b313806ed6ec7d6f715d20d15e73e69f1284e45b0b2f96f49dcc90878d39b904c314213c54b5887c8563ad40b7fa5a8f1a809470f84af26112c92eec234abafdf86ff46ea401ff713cdbe3708aaea9dc23be019c5e66d72d9eb845a1a37c95af9aa5c2a8868c903a80f6204d0c425264f7a58ecb5fe66d81caceadbee959c6dad86d87cb76abf3d69df5e2f5ee8780ebe76e7b0e8b08393bb9f27a1fa1d5a", + "3721409dfd047d02b4920dfad284078cc8b7e92b8c42c178a736eacfc5843a5c9afb543174ff07c616bd835cb5a41e92e23a2f1d6c0b3e16b5c58a29a8170aa6325bf2382a9c60856900bcc405b12e4b055db6c36b8dd8cd0f8e2deec528d31fdc85a93b343b1f68a47338b67d8b554c0a65cc886de4ce09b2b602d4b924b599a8d2d580a5d36bf02ce14d2dd9c8e660761b3f724f83fc8c090714bdc91997249060a1b8bcd609083197fc567b75e4267ee3f93e92d9a27c0ee1a0c5fafd10e9a14e518836aab1dd725e9c5619081c70b66bd48def2ba0a730268f645d3f4de08a2f7aa2bc441ecfa015d77c02bd99e07f3fc1bae131ee3c7a4bef747451ecd4", + "67f47db4e2ff41551f55b35bd7364013d8e79f0aded4ff6b6e7de2dcd92b81a718e79ec449f1f7ef1f9f8d0cb8b88f7764c449621bf0bc39043e73b3411c4b5b736818369e38e7bd1e4cf41c07a770619414d6df74126d3a18c84e2d39a343548ccda8fce832d454d8b40defa1ebf9a4ee3542ec4aba382665dfb4c0e9c96b62a91369ae21b0a0e827f0accffbfc4ec52c97d9f5a60ec9d94bef1c9d342083f2b33dca1346a7598ca56c44416a1977e489cd16ee9cb9fcbcf0b3abd130791e5bf9b7047f72ecdc42bd957c77a2de5b437d25967eb9ecf3bdc7e78e2c76d62036b5b7d8c6f6b2d7797136a9369a9810e34663b57b24544a43e023f7fe780b7c33", + "440d6f360dbb537a0cac2623852556fef70c0707796037e2520e8e737fd529fcec3c454fd6e4288789181a769f11f5f2c7aae147287af0fee11c98f7cce4cdf6be3df17b0098a1e4b222e8842be3f6ce50e9add7b8e78f6574d6b9f42514f27609d47f1d9b35b7ff1698bee678f7d2ea6861f325324ff07eb0f0f8a7a43bf54c98b2c99c9fb225822e74f13f2a58900aacd2722ff71e7df34a0d1d75ffcb5c4973308e568bac2a7236259e98f5cc4f1e7a38f7fa189a4b9d2c0a4df7e14acf60db37dcd2ec62611258eaa5ea3502b9da6ee3d7b8000c0bb04ee14f35bd53b30e20c3013755dd12bad7c382f8002bc5ea5bf8c871c34b8028515160e0c6486c60", + "d1f59ce8ac8fe3b44132acce4ef18c5835a795acb157a173392cb34d0e403ef9a39771e67dd0c12e8ebacb85af0dabbc6c3b98ff87e74550e0e57a04127686d04af2b80b19708f4f6d826a2dfd292f415555cb536c695e7659d37283ee1239e5249462039c303dbda81e269b32ab4e689185abf292d68f30800745eb23f99d3ee5cbb4f6e377e5660ec84f0ddf833c8e87d77a1d14735c43e24f30b6bebc42913d89aa44f3ed1d96d8367fe70f9e172a214442e11ec9cb9f743fa7716249dcf331346b22e3ecc88fc088bd60b2dee03153b9022857a4e072194d009195eaa7107160528968abb80643069516c9b7679c89e99ff0cd590a32abafd5ac8ff459c", + "f767bde0bb7a6d44f74dc4e6c59f6af15d25a5d5ef8b7e2adf24579752780f2f065d13d27358e45e9ae385acb675379e5683c48f85790e029e7c6dbbd2d35b7462480390eca200be54d1dd2019386e6b4adaf65bec336d1e1c9f2496f3dc90221314fe191f59d973ffe7d1f3afd9422320c6923c1fc6aeaaf5e60b4723cee748c4682ba1ada399c595b0f6410212ac0988cfb19cf6fc7c36cebd59ec741bc98cd013b1c7e12aeac6b14f10571cf5ab38550318d12c000877e6f1cbe87eae562f08e9e98160ff14d871396f9fcc98314aec707ae2c660b484ed23d9595071fe176b546f93dd4b2bef90abc36c4937b076952e6996779ae21fee91215139f1b15", + "3e08393da7dd47cc064b7647b20ccac3d68eeaacee72305d65c82e5f868da7055e1a7d0778531160ea735e4c31826f4e0affcbd9cf032fc7ee7f4d77f5f482bde1e8f9f3ca5e3e2fc5d5730ff7cd3ee40c3a4001cc586787a51b4b5ff89aa0f5560571c0e308db539bf96ca511b0be5ea0cca892bc4a987c861f4af746eb2b10f61a97812d9c3fb399d292a18e940b20a14de1250a09f78ede2fbc26d3abaee2abb1c14eca8e5a32552ec2b3af567c91515eb7e0b06753e192c4446f59f6148944ceea0ad1e17228a8cba1fb521e9e244ee28c632fc569afd0bf26f52beee79fb92bde2786b5b1011137ddbed4290187741542ddcbfb8f657e3340288b36f2c2", + "21403e95d5f17eba99726597cfe36603b38843eeeb09d3b457ba28c0681790729eb9e32de630ca87b61d8c12939406ef55be079c6062091611ff8cc59b1afd230b6d8b9f66f53f94f93dd00275994e7b3ead22b7cbd1697de9fbc15130d04ce28f2f92ccaafe06d5c200f00373a708b53e2dad5c6e56bbcd84fb2bbf557f385a077daa09de5ff9af00b8b0a5ad0ec48ef12bdba31e61d70ede9a76132b4b606f177ceb2bdd0fd54e86eab570ddf529b2475ad45694cc915b7b6be34c080679c5514a613d1bf1903fcd5f28d524c619c332088c62eb52443b3a934fc575bdca3481ada36da701b96cfe4c2dd7da3772234a17c20f26c66e40ebdba4d31aa19bba", + "1d93e11244ab022468be2e5d728a58202582c4f052767b250da765da33b3c79359429dab40c932000a7abf175cc46dd97544368a3fabad123df90f570e1fcb18f3a6dbcb36e1e40bc44e43679a657c143aab86bc39a8a97774bb29beb2a0057bb81e1d7db36302f8b7266a3e8429fb6bb4d35f836b92e8044927995fdc5120dfee83b3eafe83548c8725191ddce64af136558326d03e406d3d1bf7c6eba802a693bbdbb07682bc2630749ff90e66b378bb5a87fea20eca0f3155f44487cf19f57e475d2e156c823a3065429d5c4c85cff46f679c7bbd73b7010ac04e517d42906c89d3130222ef746b9e0078e4345c51663875ca96c46c1ea55181aad35f5ed8", + "960714bf7bceaaf6dc7b0edfe2618390afc83dae31259c148b8aa7f16901ff98d88e5239240cea9a921b701dff41eb1b54328499c51e78485c6277574852f540ceffcc265f1f8db2d015e6cb353c14136932a6967d72ee953f2eb1fd5f79530191f07933cf0a00f79783e8382a49d9a4743ae0aa613db6ad05e7475a871a3ab9f5981b56c8cec3b366ec9ad5d1921c237069ee3aaa20e2c9b9cc29b52784a1388fd9c92a1d6d2f96b7d72edb736aa3548cb60cfb6da4bbc9aff4a90c8e7d6baefe086c5e8cf9a74f9245c3dfbece25ea93c55a9f70986ca703bf64cbcdb79e525a8e5dd0094bfeebe1b97efb3450c2ff7d2ee4a3e2706a5d7d170c0bd4a744a1", + "74a30ae3c918a97c49baafb554915e0be8dc8088f064e70b602cf671abe802b4afb405df064f305d8ba849844b88be3fd5ba2ae29e9e80f54c7755a8ce0b3750be728d223c44ba5191aaa30b64274c4bfc5df40b5fa073c2467f422b89d6367325cadab528fa55d1258c8e38fde118925af2795901658d4c3283aa2a1f9ce4632aa9aa76cc94bc85380b489d6a56cae5f404cad1c8ed80c0d1c8fcadc9d0211447a5b509a92b3b2b379cdaf58dae0af67500451998a2104fdd18e4a68e2c935c3554516c3246244e884a8ac3c1cdf3f27847b8b755a687cd1fd43dd03269176dae04b4ba306493e42e5bd8465f5e5fc178d9c6c65ac7816b85522b3e3de8fd84", + "a9eb72afdce4aa5369af8199feb2cc5530b5c807ad5dcff803589f8e650fad23e79f519c38d9b58e07da078a13f6840f957923108664d803e2b2166fbf46c0d736bd8b110455fe8c3877c235a3d463b69a28a2c4eb3351c83913829e6c439e69fbf1275ccfa277d21e15f1c1d1d58da1235971d324df4b7a13b84239fb5af40fe6a147404c772809c9ce7207b09cafb187d1db86b8ef3c6342bbdef6f0ed0929abcd794522688f590c507d4a751642e43e11b30eb448cb743639cc7d552194e52753164852f8e5bff07602db584de20d0d148bee562ce48579a03a607d5d4ace0029d39fb8246cc7e35af613d90e9ba81621de2a0e5802c120df502f0ca3d4c3", + "24fe5dcdc236dcb9b7da57b7329a57cccd6abf9f09a691e188bf0386132d9c10e8905e08ab56d5d54d1e215d784b4294d988b4c0f8ac7790015a87740b01a4d7585c011183650fa9c354a62c51cb91ade1997d3ee53397ea6ddad3fd73b4c167139e97a9f7153c7645fb47c6c820999aac87f064815a0fab9f37914def4562749a5675742806d4018051a36c43d3b95d3b1415f57d74850d612a7ba91b983bc21dde274ebeb002fb40614668ad4901fe27db771aa3fa73dceeea72263bddc295f82210de44ef5b3887c57b2aa849b8bb5045d381f7d20da10003110ae451c0e067a6d2428d13d3bf2cfa6e4c4b594148adfe9c699d59ce6bbc6c48268beda1dd", + "8e1931de6740c1871a8b3d7cff1d13b273862232d9e1b5a06fd27bc694c64becf02042a2c57e5b07689a5f7de61f3859b051dde5c2d640814173942719bf03aa758fe54d2a612b436bcebddc1eb96d5e0353ac83be2d64248af3efa4b855335057392bf716780f4c38862b1fb513a3d79c0b315585400fb3dc58e5e198f06cdeacdc043ffe8680cc288f393387dd3fcc31ca72b8d18599eb1a6063b84ae488da37f41a8a639ff9e5a092879362f8844e55b3e922859edbd19dc66db6ad823dd608412d2228cc056fce1c68721897f69d0151174f8cca4e95cd9c8a45c09e4a2892c06e5f76ee3e32bed6b71abc191e91c7a8d0def32c9c7f86f03dd55b79c29d", + "8e1074991fa70c3de4a95039472b7a3cfacd623051a10826e409305d2c0bb03a5ed722faa53ec2c35c189264c4a1c626a777c19943957f7d8a9569e6d0679cfc8fcbc579fe8b7b3d0e78467260a9bd8b2e4d637b8f702eb5862a8834d9f1e22ca171fe0354e6e0ef81f57eba38563a684442fd081980abe08dd6db15bcaddcc0f6b4b8f90cf7c23c37b69fb96008ab067a810b96ef7100f661ae6de7aa4af7cb2d97b11eb2d2a79c50bbe28415eb2b17a83ef206b7a0e999eb0e070f065be7074def1a8327fc16a128d40ffd67ff24314d662bac17d339c5c9246399244b1fc24ce85f584b031e2d48eeaf35b5397491769fecdc6297bf437c247e043d923012", + "a4efe073a97a63bed2438bf84c8889c35061069fc9fa16b97e74a27157624cad3c4e8d9ce892cdef2366610a11cbcb4f9e86dac97fe459ea179e29fa86e80f91bc7522b40577e14f59c606c6ade6a51ca836ec9579350e7d61a51ee8feb4d01e30aa4c56224bf3fe08b8d62c08755c38b3698992a43c96c2e7bb2c034e85cd653494b63c6c6335c0c746c48b80fcc1a7faa2c569c8cdc34676a2dc4d1223f3196bb4496f3b41d014f6943ba8d83d6631b5ef8372f3ae3e74a4ca5555eb5944f78bdfc4bb3bd919ca802efad1b86b372f0b38280957eb68142ecd7cd5663be957db3d232d6c8a4e7e153e52c863ea4e9e2f8d6b864c3bf221edf996826965b1ff", + "74b945acc6c3f38605c21b677c2d63cd1120d204e6193e45b7e91d4844427f6c6c11479bd94b621bb736d56088df141e89690041db9181726bb976b0455aeab04d74a0cd27b4f1db5694349bed16fc6715c44ce75e62e789424f502a9d5ae84ba57924dbf80fafcc336538de980a7b4d8b1c5fcaa7367c6b291f5d84c3caf394aa5f872ab7feafdaa263ea96f833a1a35fde0692fd5a822f76a22009897d35a5280701ac2473f18e11d37728793d1a0a76777103c4727faddf26c8861bab486bbf4c3e5b3aa77e3d6bcb19e030b1ed853b6c09eed49f8763a548d61c498ac3f6897c470d1d9b24b76e4ef0dcaa5024e8ca3f3ede7cc76b17876c020d74f434d1", + "29b747bff626d7390eee50aef5d31aac6ba418c2d9f0437f6ddd2f35af4ee00371ff8e211ccf707c37bfe29a255ff77d5e557667cf1044f7c17e254782dc5187244162cf51918ed17e6999620b12e81f801942e046495eb8f083a05fe1aa2fe2cc929211d13671858675dd22425df799b320d1a1048cbfcb047c910af387e473aeb4de614c9b488593385c0b4efc0a00548cff0a2e05bbf0a48300041bd76a58115f93b7d57ec0a994c6c0c3dc2068ed9f4ddd53c228fcfb13187b6fbba849150a285ebacd83fa655e9fe8ae7ea98dc460d3625facf6c27ec8a4870546099d99ab0f09b006c088d56a98bc2f0e8d986d3f2823deb7f36e8e2fde816cf1ff9781", + "7c9bbd1d8f84ddc53fee9c067282eb4d149338719248afc0df9f55f805a819801c65a12efc96bddd5a47e87e3d28d316748dd0fadcec8e9397a9140e07c3610727a4196c7f9b70c23314dfb19fb7dd2969e3209f9a78d81f6d13e72382159a4b928f1fc2b141c08fbf522583814f66b28e24647f708623f75e50d462d90a481d9c39ec3c46786d7e434166c5e7f526f30b9be477888de77306d53e64cae162c19cd34eb7083603d770d54bfa3928a83222d5966c13140bfc2ac87bf3ddbd68e183016c6d17ed5e52b898df5c70bbefccb8a792e06f8e6a53feeed69cda6fcde13cde3ef0c7ba05c9167f8a2b0e3f3b0378d7868ec14909e4072aadca46a1ec2e", + "52c18d66109375f0297c540997a67657f2fb0936a490b0da5fcf197475efde066a872e75e2bed709ff931e60848e1c8bc98ecb30d0a1fdb0b2c19cad2c638324c790f0c1e4e879f84c8d892115f0d9118adee108da9f36c4a68fa0a43e93c2540b3c9bcc78e93f15c99d59416208233fea3615f993d21ab26d0711f6964587a40de61df7b67ff7e5ea18373534f9e74382a19ec0f88f8ee606202d6d90df8f8621001d81c66898679282670e7739bdb86054e3b2fe9cde289fc9bc48134832eff2b59e1b6bac6ec487f36a88477367d1ad565bb594d5741be94dedc04f7b2ed81c981ee5052f8a7cdbfdab942edb92a1fc67ff4c47b8261bb5bf3d5e36c55fdd", + "9b995fcbd90b493242801ddcf52bbc4663b0d996770a7eff661e18d7e6e43a03a274f24c631cb496b224cc08ff2fd9ec1f0d71c43f7ffc2fdc0a829d9e7e84f084f616791b43ba413e40232cf642790218940419f027cdfd2349ae20411e684d6022015268b030c5215cdc3948be95cb758fc608fe5a4e06af01a8ac20f679d1e9eefdfe5556929d907364850937014c17dca07556ba8f1c2e427c8a98659c3cd4c76a74a04726928c558dd5c30f39b2b4b8bfa02066929ab357a4c041f6c58e86ec1f1e7927f12feb13bb86491cd45b00b751c2b05d069d39b45bed3adb03483482cb088a2b87e9a7cadaf02df9dd3214bde184f2baef72adc0d2ae3feb707e", + "8d85093be3f0c4f8a0d29176a94bf5e93e57fcbb7c363e92f07684c2008dbe1fb91ec615d1c8c841594de9eb6105f2d67d9bae856e95e44e3136a057c1f31469f13f5e21442c17c8214ecbfe6aba256db65bbad18bfb596df2f512c6b5b91c73b5c8af9ed395f094f6cdd8de3ec4049d10e129750a14386be842555aabe84c408c96fce1311864544b35205755909bb10fd6b0f8b013a00e04897153dabf7509fdc8ec562534b91e95299de50b37656affd99c4e2094807bef318c8ffa9f94060480d10f2ab2cc99f95af7efb3c7e6b2958ea9015ca62923786d5628a3f8001bcd0f5b10b19cfc8ac578e157dca59d6871ae3946b68a8e4ce1ca3700127b0e15", + "57a12764bbd72f15cb481da2fb283caa7e41a6942e3f69a08183a39d9410f3a2757a40e1e97ebd6b8fbca7119ddcfec26555e50ce1cfa05c9a71da2a1aa1dfb1668f2e10a34ac38eeb8419b3f64b55c11b03a4a67628b2fe0ad793658f422cb7f0b22ba4d0fb060506a1397fd99180a4dec1190a3c001666eb1e34285c357771b21e90bc9a1eded1ffcb0041f30f70978cd09457b8870697a76b79ca838187e15eff92102e9125bcaceac711eaaaa40299f090df6be78075bbbd7aaa905d5788ade41634decbd175dc7a9d8a67395d54dd0bb76e3102b5117292d502f8833a39a978cc688a9cd223764e98e8cae9a37112a7da56f3f39645e45d6fced4d4af86", + "a0c37eda18e68495f3b5c791b22ae3077bf1d441ab8d0963476e7efb53b3313f21873527bf3758992ca0fba3f220af566e69bc23f1ac1dbd21388a32f5c549482f47bbe6e1bc8c1b822b58e7b5c60233a9fb9a83ac568228dd6e28ad45a541bcd7b303fb8c52c99e2ad6fc5324e2c91c96d414712c7d04ed3bdc0da4c2d26fb12d38113a8d3da4f305f6573cf687e6dbf5280362a2a0104ff43787de6e4fa16d9242ff6c086b474c1c284fd6fc8d8f39abc0a4d9d253e5597a7d2082951a14c56cebd06b6324c7dc6cb3ffb45e6e41147e0a14e140b000457d26dd2cef2c4e86285c862563cdc44d2fc07cec987c4287cf67e3e61c2d16fb013fba7ed554bad0", + "6684e12270b4b17c6dff1a32662fb99a8ce1e78a2740dd3e9cb7162f61f8c11e1c78aae4f2d12d74564cb53e5db3d512c29e9f7e328bb18e7425ee646b8a77ec4b8e1289ae74f42b51df984df6d54695ad4fd60d54bf364502b1f1f659fd8da1765b05ba0b3f1176a623e9990cf487c591e42d2d6af3a7eae9a5d446314b23deb2fb2a02a5d20285a60b92f4cd60706bab6fec32172900ccd9fd752ba803f9cbf5dd2dea6d250f39a21966ae521b7b56e72c81bc0311cd469667e8fe0b0727739516ede528ab32c6700488bd0cf6843ad9afc4610006bedd8d8231f972ff89defb89c92cea7163dabae10636f9b9d44390b507f2fae467ac26f539e15f822b64", + "2b505082ce22ec2d36e122ba80183ee75cda64f238101b54747cce211c4387e1ff741a9ea8494d4973b726e0b2a9e84498aa166fd43577eac91da4cc11097a404dc7d4c0031d0784390733a89013cb9cfdf8b35d119f157bfbfd566d02c9780995fbdfd67345890f505dfa0058c04854187c55792e2556af9317a433ed7b0740ac70ad0f55efd5e7e293c009f19d3109cd46fcec1612e9593803122cff5de6047004f344ee1274b93be05c84ea027dd0140d7c95b542b949055338445037abd92be50bf5d7c86203db7575807d9c6e32d6f6e73b85f2ab97dc7b4c39da1eb2fe0d6b050254b04a9109714870af8b1dbaf9928f0731acbf3477fdfd72d456521b", + "9973cb9eaf649cb937825f97c0b053c11e7e25bf6e9ae633f31bad19ae10f90417ea3969dc5221c35f3310dc1a0424372d57ef0b385cd30843a74f1d899c327ae5efadf9918c0f8c67c8ddc8e578acc5dde7c46d3ecbb2b9b0d2d123ca3f41d2d1b4c8dd32b8fd4947c207136cd5fd6b45c50bfeed111269d46e06a44547059523e6bda292c6f10aff83c6e2de0842221f7b072df4a7bc2c5c7e0f3413170fca9be86799ea77b1b785f923a900efa006f5d53430cbbf1206ec29acf821e18549fec87002e35fc1028e297fd96f62a8b097331585565bfb438a750e309c8dc3a15543a260107611c3c1563a26738cc3bc99cbde02f42f663427c36dd3a20721e8", + "1669ce0badb556721b9eabca22acfc0877aced91ddb910a73a10a3ea94b8e006b392dc920759ebefcdb8676254cdb67c839266a8e924c7387940cf18b0d1aa784369aa1beeb07d3e511f5577b5dc6d1b6196fae0511cb14d01c812f493f15da94912b59ec19cd22c016b5bc4e6385c312e22cd025e9f105df7d02347be3620d0825fc52d76622982572d07c5b4c6ddfd72ae8dc47a8244eea4abffae94c57f3dd01cb2ad9ba631c73b9eeef38aedfc0cb9b0d934732882283e1753acf71e40034dd9d825df271dbc47cb4d3f0327dceb449a0e572f283c5265011f9f9ccf868417b41184b35429ce7d6b1399fba7baf250474d0c448861f926ea1e2faa1c32e", + "78d8cadc538fda3ef5323ef687d0245a722752e1f748f326bf2a50047e296870eb997cf441a4156229a4eb4292ec1a32806be1f8a1808e71f55aea8a638a8a8476ecb1bc1011448e50ff2f83d220fde781d0c7ed09bb1b51f42897eb3a582cbcf18ee309a0c74101d446a7a6e7f83b499196e6555041a1352907ff9dae1f8c8b61c033b79563a8dcdb500d340696107d06793f190e21a7a27cd4146195712b873c1cc19633eea87b645665738ba5475a76be0a4e4a3ed0578ffec307da033dfeae3e0e6f005ec68935bf6b633ef6944d968e1520cd735e7890ecf6e139f6a18e52e6d5992336083520562c0b34def46478b60d608cd0bbb368b584a7af9a0ebc", + "a94721573aa9f025bbbe7d7db124dd60ac7d68740784e448e9144cf7b9407f616c2b5941550bed852fa4757947a232aa3f09970ae70491548bdce5065c58e67bcfb8acd12a341d3194582e61c0ae039edae8a4fcbc30e799ae0f6f3d8553cd5363513a74588af77586f0a51346f4e6ecd489883ddb2076150c97dce110e81ffc277967f355a33061dd0a1f880d6284cf7a01e71f9f0c536c91ec9c47a5ab58f2c11aafc060750024e7177bce106f8f807b5e848191e8cccdd8ae24395ebf66ad7d8e3517f6a765a558208c8ec00920a4a1bbf937396871305ca1c5534387829946a6e1c88039e7d35996e56348c5fa26e958f65c052b5b14e5538a666349e5c1", + "776ae48d4bb5e10d588e6656fcce6a5ff3c3f1917319ef8e74a0bf6c97b0aad9b8b9954c4e6dc6e66c7f88930f11f45f39097b57b30b1f36ff6d736fc1e2720ba38ffbc1576a9c20b45baf11cea86c4399e95ad7a9cef22dda50b5e6323fde64f2e68c5175d88f5978755108c5471dbd6245b3e8ee38900ae88e1652f460733d3b2121b0a756a6e2eb0b402dfc01a28f2d407e25897d155b255c1b1d284b418be8045524d6a22001154e01c26118508aa867e09609e81aad699b88af490c973848794776caf77f1ce6d44413a06263bc99c31936f4401e71b9d714ea1b756c5251ce68a3f810a72dc7c1f65e5d87711abc1edf894a6eb98d33f59d84c71d2689", + "79bb379551cd64c86dbb27e36e8a05561946c94e8333eea36f80fe7cfac886a2142a6ed80a9a1dbb3adfa50617e659259a59a48cd7c6b8e15479baafc380d8f3f68de96ac2f27032b2a88a061cde4d54958336b3acd308f1e2df81b2d9e0bbf19cb364d5d676055f09c976896450b4e5919626a7f300b3cc14a6e01cc92c5c5af641b9661204406af94cf53a7ff730c362a0fa16d203adede9e3f1a22177fc92bf048926401055a5b4920695230c5b70028ab18dd1d1b87d372a50c530f376a970832364d11d9ec9797770e1befe97dd1254b169332a14c0518cc1b903840b62993af3f25ea309d6605ab46fbd58f43de22e58e6bcf02ee518ede613a32365f2", + "49133ebd9b9a768dd7d4d60dd7acf450616fce96fae917a751e0335bdb05f5baf2fb147233484b2ea176c18f04a50331eb07e381c581d6adbb5f7e091dd59e1de32232b9ae0a1a2a8771c30cb80c042c24acc275ccb51bd160fc19ff5d534f33d4d07f08d32ea0cfa3e3c63ca2f9bfa397b2d78a2f686d75a9ec68259169d490e738b62a28843ea5b65c50811ed2768d8f506beeffa5ebd0d6ea351884e277eb886fbbf05d3e69895f3a83ec04811f95ff586c0232d59321c996b8834c845cd2ae6ac8207e96915b8ad2a67c27c6808f182801ebd564de92aaf0bcfac5b2cbc3704eaf90f94f6eee97ee3fc0cbbbfc488d4976afb477883190f19c7cae327a31", + "9777c0e701577851a96356cf559c95b32585375aaf2bf7bb555e066e85d42f567203aa5a4608fd7b25d371f629ceec719eefa8a84b1b059eb38152fdf3d74b403a4e347bd671b8128fbb6a1d8dd0dfa4ca2ee46718dc4e69d286e9f774768e443161f08631148f9a7175736e37b113ff28e8d0e576e1a9f42c25bba7a50d05c11f22e5d6cd9fe0ec8fcb7b80d2238a2546c625f52a53fe001965fc7a4d1a999dcdd86f0c10921e2e285178a933fa1241a318338ccb346f190b390c5b294d28e49eed19bf5000ec406460e4f30feac08538c5612255224948b89438932d4f3af23099ee9af6501121730f3ad1d67298ab12c27e02e01e04dd11d8091ea38ec384", + "91ce3eab50d9770cc9710a7b5cdd247b89d41c2d84340f30a547c618837b6c9f12234afaec821da80b57b677185774cf2d340fa97cf49fc567f87420832bd6509e3b72497dc277c376929f6697f28f7c08402b073ff816e82cab00d9717b9b4c499a2afe646f02c2b6eb0874ce9ba291bef9e5d84da13520cf84b6b1f946af10c9461b2c0c99583022489ae9262ec57271169c377e4b33452f289fca583fc48c4db53f05a046ec1db2fd77f34ff84faa66b302f3fdb7af22aa1038d7b2fa0b14537fde1f338f7b9b821631067d699a1b2be204f8dfe11e4a15dc3fc9790369cca707bad1a5ec845f764145881cd0bcaaf8eb3f84b159a3df6ea3523c9a7af23b", + "6e72d9a5bfb56ebaf64badee7e060b728722ccb93820942439841d321a6a9263e007cc2ac457bed15e236dcad0af32fdf950a6cd547bc61fb4b53813f410bd5685cc8372961f1a915a99c60683cc7c7e3ed46af42bd909d6a435e8d59bb6553f16679f41960f79be0b193c6f64bb64969a3c81c4993abfd82432917169c98ab1a57d13f6db506097ecf136684c08defaa6cf111371e4b041147de2f6901e22a19976552f34e62721924fd2ec65ee441ec515a6acd4bb056c312a262e725c367c2a68331d6523723e381467e722773d84aeae4e301279ed443f524bbe2c2ebfe20aa646fee8f06f36d87c45ffcd6299af6f28af1b089fcadfe895f6434dbbc360", + "9ee6734172fc83ffedf08ab30869865399e0c3202f992f6f2102f3fa64d8253ccaddf9398da763921c492fd7b248e2c8397b8f52d559008e17dfee62a9a26226fc6f3f7d19ed25437a14f727d101a304f64b03213229ce0d6f9d0cbf9e1749734393422622d244b07c037e1ede93dd8b8122437c7d73aa36ad36c7a2bf523b81b6b49c5f5f14c5c558a82a7227fe70edb8023be28663f558a7e1adc819ceced5e48b9639becc2af30af34d4c18f2286f5affc6dc28d3fd189fe0c78376f41411369917cffb23d140f686e99d09f5474091fe4b3466e621507687b195c5176abf01ec41784371b049f2eec1111c5ef9263f51f10078adcd008241b1cc80454abe", + "16812e25ddffb30c7cba2aba93318e4e4341cb6acbfe711e9787fcaf2219917344a9f541fb58d003d60a9709c2c9e64685f3aac5f1bd83f138a3a75ba4dbd18cd59b8a9541075ab63bf62b4f594ed66e461c70db243df39f8a5c1580e4b4af23034d8645685dc5982a6bda62c41d43fd10a45f8a32f084edfb32fd0ec92e652384855147c46b7f06ec8e5701f252ff15ae17b23142f28a6caf05bf7dd0a52a561ef35a2fe98147865dd95ed1d23a726caa5c57384263ae29954ef1408868ffd8006ebfcfbf9b7a792eaa5f9d9f99c8b4e2637246fafda805025b5d058e79c813de3825ac42b98c2621feab6628653317c8b0b3b204bb8d260fde545b23a60a4e", + "19a37024d388236e6cb7ad0ac029b4af0975cbf3c57d1abd0800b51b30c08a816fc8b13d50a8a6e2d729a68152442dfb81210a30cccebde714386f72f457898fdbda63ae3923e072a060a7af8508b12b2daebc8eee834522468825d6a87d199eab86318382a37ed80dce27eb0c589585873de1af174c7e96cdbe24021865621557b7b0b7e3cf61ecc7946410b36b7cfd927069915cf1c39c309e19aacb8321121db51bc584f21aceee10dc8d2339273e6e6037790b131a48ff5e892316929416288b08119d77d9770c7ed27d9deeabfb9e64937c3763773413b2a57164892a9454399d6f8261a4b349ef630f67b3961507133ba3a89e97ed0ff88ae156a1776a", + "73462ab8db0ed6bc854c4ff40f51501baf2de63ebbfc0bdfa83494316f69dfd9bf71da0c6839cd6895deb115ce17a434b8858ae89c8d3a126ee4d842ea29b49e75ec21dc6c92ee1b0a11a0fe4810395d33730b1c15a28b25b2de8f8daf3af4ed2c5430eb795ccef4ee24d50a859dce6c5c2fefa44e38fead813f86b3dd33598d7de6296cf26f5a4f3fb056d4368f6a19b8d996b7fabf9b7d9c9ca53e84d964d8aa668b2a9ba503629955af0481440c62994ce10aa6a0210ae778f96ebfd5555e9c68a66768eddef31f073522ece202d479606f0652cce845dfd6df8f984746404122c9cf1566bd3913a8a580496fc0593b52a94788da278b70445a49fd8a963c", + "58ec7917f8af472539ffa195b8abcfb0c944c90ca90e0c1da15a4abfa63f98a79d11e81e64e11a0634293ae119d71e4142444f5d00bb4308e8698be30a16947e6625932ed4c777169992e69d1d4565ec4138de9f0d7e5173246728b9c52a8a78da4a4ad0aca08d9d40f0bff43141a858a6486255194b003f0142695f2eeaf92b9de3943f146735f1f0407d49c100af0c3ede1e9413ef86069d07ad1b1b28609110b1f246dcd6aa869cd66376997c44ffc2477b83c2f8a70d1e06d699f6e938f5f47632eeb5bcd246c86f71f9b715a2603c5834da45437ceb3640ea93ed75f0d536cf653f120ee08b022dd6244bfe56e582671f605e9472c6023d0a5b6388be", + "56466fcd317e0d8ccb4f92bcd2a2d8489ff6e4beaac452cb102769dd25fdf6b51f457161dc06a513ff1a8f31828331b7aa8b7cfb5445c7c5dcb57a554dd1164fef7e3596c1d33532136835d421a7011b151cf02c39e945cb7ee606e13fe18dcfbce6bae314a732bc6ac54e1badfe2aec42da10462fbaf755a9133eb6d90c539f54e557862bd65c4ec447e0e8be2be84147ff619e1d90b24bbffc89a26ba7996f805a5b0bcee5cea502b212ac9980add4b80c39694c6f0b1c774995d2fba756020c7204a4b3659c379ac1a8533fa4d37175bdaa79ae6105abb67282540cc2b8ac347149ee64f99306b447562869c6b7431073a2f4ac056f8ddaf98d0bfb600b94", + "1546cc06beaf03b3516c77ef31b9e563291c99c56adca38afebc74af6c36966126e6a58b16e80fd1cbbe9c1e314934df21c58fcfdc13e5dab0bf8fa897c41ea5d23f7eded36b69e08cffbd035378829e344d4b260fdf69082859cea58dddd155b627b265088c680fdb8600f08d3b15a4e7b0b8dbaa5180cc0e9b5124b9aa3b8a9c3f87a810b8063307b619359499bf3faff284e0eb760af961fc105d2375e98563f33a713f70cc83642e9d840e7b45578f03c28b0a58059859b56cd571d299fd9f4198a0c36c13d9932eafcd0918021020e50df914a3ffe4d489ba4eed72775bcf75c4a379341bb3409ad2bc1910c4eb14d665f576bb920b27558c08fd202530", + "26be926f455caedbb9cd31e0ff05f5860263feb0311ef41575a984f23439cc0ce6509e09561b7f1589b487aa13a7ea0cdf558db6d2e8e7cb967a243b590c903c8c45064247a1e7376cc42d9d2be97d1b94b5a88deb2f8c5e4a4ae4ba871703d0c0d83973aa0950fc53ac40d8f03247ad6ff9b682aa8a0b19e557e0b0a06d16961e8e3a169b7d0b4f818d96242535f30904b4af34bf5727341161ce13c3bbec4ad29faee971480f9c366614ed364765073bdb70740a88447eb0a8fef1e228fde0e1bae471a64d792464f301473b12b9252bc2276a6d0518309847a55e04efd8d14007c274221a75768335ec7c6da2ad6210a131f2789d7b292e5cd8f05649ac2f", + "7083a3c4aca56d0cdd79c4b6a8cb82b71311fb1136186bd309d70a97636f5242397e29ab241d988630f79b20d4d0686f99873bd79e6aa9224489b046d75f7b15b491eae8d3382abe56a4e78374643f2d2623f2268bdaf5664c6e395c7c1855d7fb71f852dccb6a1c2395c4e83214691c0c2ab92ee14896ed084bcbf6708dbb747e09a36b0023434781a935797c18004f96e511f7b5200063d5d3b9e4e4eef2e79626eda77ba2c4d4ef575e735b2d8d9cf52eacb48a877b021f7371a74081206d1b741889907636c171e9a9d74251cdfe3441be87e693816fbfd89c7ac4895127544d1ee8324e93d5c1da1671c9e37ace0e044ca452c3c4fc21b2b203d75b697e", + "77d114b778f6625a363d6275490d39a68d0009c2bd1f419431e80e45ddd6c3e36bb42bab6a4b6df34f329a37624aa8ecb1bd53b8ad1d2bfbdff41486b9c67c0ae2ce75cbee14650488dc3e23d6c0b432545e0767dce60fce982342ec1e1afba6c134940a16a1ed15af6eda6415be3e56820821a6e83b509dc5f3b87c83247d23610df4ae37ef12bf071c52ade358fd12ef798f0a878289265a90a74e48e70aa1f42467983ebfef3446e1b8d5b2b2969c75d4bee1d0f380e16a8f6a46cac28fb195ce6743133c2109ab323fd809558353d7e793f828b78e8e7fcd9a45057a371320dd6386da842652d54afc9d93b1dc8f1dc64f23f98a6cc43a4e16782ca73e44" + ] + }, + "provenance": { + "go_toolchain": "go1.26.0", + "input_fixtures": { + "keygen_data_0.json": "d9de3a0fbd8ae8f11c7d194c71be7d40b3a9581e1b2064f1b5be10ea2c2cef5e", + "keygen_data_1.json": "22c591a6caaf2f5a04c80ca88596dd07358313627898e26c602214b10a043629" + }, + "proof_source_sha256": "69a2480cadd102d35c0b017f448733c50645e3bc1148b869fe84f03ae4850e79", + "random_stream": "SHA-512 blocks over UTF-8 'R01/' + proof label + uint64 big-endian counter; crypto/rand.Reader is replaced only in this generator", + "source_basis": "github.com/threshold-network/tss-lib@d847ce003019 plus R01 compatibility patch" + }, + "range": { + "challenge": "af67a33fde217fd5e07f93b87eab1f6e49fd15109e2a26364dfe0a258c6899c3", + "inputs": { + "c": "3a0470bc36ddf902d063c077b0e557be98692bd242c9cf3506ff8838fc019f41c09fb4d9a452f2922a72dd1ca9f8216a5efd85c11181d01355c852005f496b5080af601fb4ebf2d23ae45cbabf50ad517b2d2cd1247bf20d98e1739a00456d72cd39a5a7f5d2707c63ad633eac0f0f271ac2a582a79e9fa1988c508577345b695d5752346961510a5328ca33bec0d667d19f85fdbfebe3f9c20eb1fd5c701e6d0aab0b584fca16412874c097dcd6ebf5c6bb28e53e2e6b3cd74ac17130d5ab82f733a302d71a27fa569c82c58e9874866c24cee255245ebe42800999ab18e9ca198e2d518ca20c1c215b8dcd3e741cb9e3cc035102bd8c9e2306233b4c50a4586a484470002453eb61d1d15d1aa76590efe3a20bfc83a2d1477aa60f5215c33a6933ff0848c397e2cc61d3e4dfded65616f37e9864d170df7584ea92094b7dd2a6941a3252047c9704843237a5479708b796dac71cdb6c683ca118395a986bb08aeae0df859e9a001f6e75527d0dfdf2291b9cd690ce400f92a7a4d68fcf70926bbc25dd3369f01c0fc1cdbe9440b5f8f19d3d5174979f5bd1c94ec3e4df0c09f807aef71efae41b27351310374ac7cec30145b9284cb7c266dabf201471b8fbae21f24575a3ba3060b907598200c9607b6f4888c04598a9f0b69246b027d44b2248bf5cf7c915e5769784147786aad77dfa285b398e03580a6f3132c3189da0", + "h1": "f21c50993ff18390db9d37e26621809065359c0ec1a70ec0b90b71dc10a070305519e2dacb54dfee66440cd4219c0bd0e456631c0bd326627c1005f36e02432b03447149a4ce0e62556531fe907bbafd11e1059af12fc1fbfffce9205222e42b02c18622e88eb0dcd22f098a905cecefe4672e7e8abe97044f1b993f5294907a5d595ec23179e82717978d594f205c5c3e904512cd998522b933763b3f0ae56ee684c1743ca21c86b6f98f5200fe352f3c2bc5641d8146077755332834cfa5ff2663af15ca0b7a239be9b661885be6f39455bb4be1c3b54c2d598683c9731ace5f19ea7ed5c1fa85f8e304a50833bd1a66157c92ba2d91f021400d736e39b05", + "h2": "23356a7ac492a79b204f34ad22f474c3fc03f1254d2a4d24ecb68a670f1cacd6c2d6e9522edeb8d8e58da89587ca88ba878bd2d72ed3ce74104996a937d7a5b8e68b26200671757e110764c16b2ac2671e03c56345cca8bfe43eb514a8c7e1f45d05eeda3b4814ce63ccba37d47756efc7436dc899c4fb85832a10d05e11bd3210bbd0223c19fce9535c0d3dcbd3cc29797fc16a25e5465c400fd0ab9e93dc4c8b3ddc0e736bb5034bb20ebee475d4a837979fe6dac91f967a90405268ab6293498592c15d8c556ca5e893189f20cb4f93618818e19ea2fd29b44cb3bd3afd7641d23eb22151f25f37f6c318531d2df923ed299444883313bda323a591c695fa", + "m": "5", + "n_tilde": "bd276406344107286ef49a2acde336f5975dc24bfe350d57501071014b374537099933214fee6277bdb4138a1b5127a2f4417c30c9b271dc03e86896522a1b18d25f545932f91ceb5e037712b1d121012c1649a6d07a6acddb225a6804e58ccd9fc88d5c872ed5912c5f4179747b828a3a9740331b0d4e2157ac88b517c8f7e01dc6475d61d60194c31faaa5ae381c2615d7f1c4abe0a3e544811ecf0d1494461066b354a201a78e40e4f289accdfb15445e1248808a31590d7a70659f2c55721ea4a821610bee961924a3af65a0a601d3809d2bb9e223b94c96b2f2ea926af0c2b88b95dd334cd683f3ed3f5c446e918e9b23d219c8a9f58631cc94aecccfc1", + "pk_n": "ab9acc348c6290f126cf3cb35e29b71cef8cf1c98d21f22276d540efb4f2a74a722d2b2ab6fd3e400621de109fa0c82104a6111d476da33c679fd58d32e32551e1f8e4b39fabd9ff7c6e5bf76aa5b7ba72ca79bb72eb68ad72975a6d1cebd0bec34cf56c9cab4d39f6280206b001d6495b6e1c58f3b050be29e078aab5cc45cc201922715dae7f72bc8810380a38c17b7838e6a18b804e2a25d2d22977fa26dc63161130464af47dd5c42dba70a85a0bfa2e3ca4889abb3cdcbecf75165ef6345ef1e58f9929df65ce9bf33a53e8f1ef18c73231c70f21a30c4c21f10693eba687faaf5de5f3b27e020527539b3a8e8358a929bca06c1ff6c3a2720ee19bbcd1", + "r": "3" + }, + "proof": [ + "249fd736045638592a87424cd8c566b17a5156ac41982ef61c7bd83daf90aebd19d7c9ad3aea52a5ff4d4836d8f079812d0832f148762aaa1fe1a758231c3c57e37afccc5ae932c0fd708a61d537766c94782e4f46e11d63b8f0e6f8f6194bab581f01ce01fb3d80600e387a521be45d9fa5eee63128f8279f41729a4bb36f487c4dfdb0e88a4abd83969ecea7d266eca50528915eebca6d6a7cc283a4a5d8d3eaad441138d27e15778fc1d0c347ae769c42e6d6336a66ff61216410e453a09a3833efdcbec450a9f10ede5e139e0af5d9782746b02efc85dd1af890320334a14c028be47516e259a26d0a45a581447d69d65639c654255fcf7403b7d0415c54", + "676a8bbef4ec87260af2aa1cf9ae62d8137ae4886a46171879911c7a091ff1410d55163f07d94be7f19c9da05c3f180d57b6952734e32ad2bb703d2583c3405c19f5eafaae4dbcde96f3855659afc9d7a4c932dd7e491742c0248047359e6fb4d2d6e297ba6dc633f49e99ab258d31334d59cc988b552e62e0e456f4a0fcf52f5e9dad9a166d6aa92e50c1c2f45a689958977a62a0cca2da94cbaea4cafdb685da0a871b3a20fffbfe00dd237f817a106328c041f4f0baf12bde085b4a522f797725ba4b84be2df1b52f7512551b7b9d1e31401fe377b06e12853b265307039e9f2cb114aacd096f9cf88a6ce941ac1f64b35e4347e6b03e8992c366e3d901c9985b55b0432312edbc5760182ca13cc5206a116456aabfe5eee87e897381a2cae4a30807dbde5117c0e2841ec03d0437d86328efeee6b41092a49376ce7bdbb2f6f3be6f1d60c6ba63b4b3f9f8c2e38f82581a321afd2b7c0658d0621b0b8ba62a9149dbdc49d6c82fa3471b5c19d8746ccfb813019cee1698f2fb113e53f4da505d85fcf1611fe5316e770104e654dbb86e07236595033dcba6351da7dc28c66e879b57ab749592ccefcf8d937d64b841bdb8ce5e6246782f4ab58242e8150964bc5d2f5eeb129c72224acf6e74b647c55a54a7e9f416e0e2607bf73935625592d0e05ab3afd0aae187eb75768f11a4aafb704fef669ccebfabde1798b33479", + "1d867375d7d820a408b1f9b8465917a92c9c96b7eb3d651733aa3dae967ea8eaf4b2bfcd701f8fdeecc1eee31c11de150da463438e76a416d4c64d7aee414eb25f4f55c880c1ef538f1e484c5b7f65e2d9fa7e5102fbd8abdd521fd190bad00ebaddfd1768c4ee06048e588ea77b292ccee31f3cf619b732828dba90ed71ad7f01c588b44dcc297ad7341625ac965df011a3349719acdc5104e5815c5fa530f9950b7357661234aac2b1b7d457141319ab9e92b232036c0d8c42d89d92da2b8f24353afb5d369bc201c891bcf70af799628746a73de5f8a1edf1ebdc7d04b01c3dfc172a5b6975730f31cff5122c92b9ddbceea6357560b1fcdaf76a1f9aa7f5", + "a6907cec2709e05a31ee3f8ec9c486a13de2691177ba0c4aa5ca0ddc720f83fbdb4fc98692886d300facd2d02476a59fedafc637cd1ef69d2e015587ccb2b3fdd6e8b40d39d11dd496ec382800a4967910ff84fa90125c2c964f3f0ad9f3116d6c8e5fd334339b3152e901e63edbf30e667e70ba5d853f49081aa3f8d5a34a0d6c7b7a4e24e3e4d4e1c8b3687688dd343217e383646a7978959e1a9fbe7f4edab13e1da172d882aeb08c0182aab8d7c5e27adca41c8172fd40b4d9aea21b1781bcd12efd471ff13fff7d198d82fb1c64ac47ddceff0e4655d63a0633e2da2e4eeb5c2a643a88951babe11d8920181f42e149d5b8086799a0aeae0a57dbbc8eff", + "8a65d413baa8824feac3aadf5b898131c2c310359a7644489048022a91f21e973eddbecd34c7b712e659e2734b51fab86fa655975b05d2624f28e570c2871f6c79f084cb5468d6272770cf4b7937b95fe3097fed6d2c44f49bcbf0babc46b9d0", + "4eac3e73888e92848ff07d543d661eee437ed9d40e50e302773284bd7f9885fe80f297e2f410d360212cab1223f57f3feb86969fa9bb48d452d9c4927d06a190cd547c201248703c0678c47ebe48a96dbe977007aa9b082e5630d30d9e74896c73ce03a3de19b9918d9edafc3155501b6b3ec63b379be514fe595862fa4ebd65831f7d0c7477a0f3d8da4762b49a7f7f2801b910350076e9176f338f0efceb75c8add3e42525f3ea3a370e4999540852f3648e42861e0c2c23e77446f31b76673b061d6ce9ebf4a25aac67bb051608a8ca147328c8505b34848ff97e333c7d2370885eda94fe908f6c3de180e609f4c9fe00900c72d576578934083be238d9d44844df96648d529713d297989570267dcc86dc464871ecff49951fb554dea5a23322c9bc26cfa3c340aa7ac372f4f8afa8a3033bd3b9a8060874a4be305c49e1c4e1be4ebc4cdbb2d9cb3892b392cdc8b4814271a7b48856024d68eac643c73a" + ], + "wire": "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" + }, + "schema_version": 1 +} diff --git a/testdata/legacy_transcript/r1_fixed.json.sha256 b/testdata/legacy_transcript/r1_fixed.json.sha256 new file mode 100644 index 00000000..492284db --- /dev/null +++ b/testdata/legacy_transcript/r1_fixed.json.sha256 @@ -0,0 +1 @@ +5d0ebead52362cda3eb8f7b14afc5e1d161e9bd531bb2b0a79f0c643b35e0b09 r1_fixed.json diff --git a/testdata/legacy_transcript/verify.sh b/testdata/legacy_transcript/verify.sh new file mode 100755 index 00000000..2af92298 --- /dev/null +++ b/testdata/legacy_transcript/verify.sh @@ -0,0 +1,37 @@ +#!/usr/bin/env bash + +set -euo pipefail + +data_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +repository_root="$(cd "${data_dir}/../.." && pwd)" +historical_module="$(mktemp -d "${TMPDIR:-/tmp}/tss-legacy-oracle.XXXXXX")" +trap 'chmod -R u+w "${historical_module}" 2>/dev/null || true; rm -rf "${historical_module}"' EXIT + +if command -v sha256sum >/dev/null 2>&1; then + ( + cd "${data_dir}" + sha256sum --check prior_v2.5.2.json.sha256 r1_fixed.json.sha256 + ) +else + ( + cd "${data_dir}" + shasum -a 256 --check prior_v2.5.2.json.sha256 r1_fixed.json.sha256 + ) +fi + +( + cd "${repository_root}" + go run ./testdata/legacy_transcript/oracle/main.go \ + ./testdata/legacy_transcript/prior_v2.5.2.json + go run ./testdata/legacy_transcript/oracle/main.go \ + ./testdata/legacy_transcript/prior_v2.5.2.json \ + ./testdata/legacy_transcript/r1_fixed.json +) + +cp "${data_dir}/historical/go.mod.fixture" "${historical_module}/go.mod" +cp "${data_dir}/historical/go.sum.fixture" "${historical_module}/go.sum" +cp "${data_dir}/oracle/main.go" "${historical_module}/main.go" +( + cd "${historical_module}" + go run -mod=readonly ./main.go "${data_dir}/r1_fixed.json" +) diff --git a/tss/params.go b/tss/params.go index 2245a056..38cbcfcf 100644 --- a/tss/params.go +++ b/tss/params.go @@ -17,6 +17,11 @@ import ( ) type ( + // ProtocolMode selects the wire-compatible GG20 proof transcript used by + // an ECDSA local party. It is configured per Parameters value before the + // party is constructed and frozen for that party's lifetime. + ProtocolMode uint8 + Parameters struct { ec elliptic.Curve partyID *PartyID @@ -25,15 +30,28 @@ type ( threshold int concurrency int safePrimeGenTimeout time.Duration - // sessionNonce provides per-session SSID uniqueness for GG20 proof - // binding. Keygen and signing require callers to coordinate a shared - // positive nonce before Start. + // sessionNonce provides per-session SSID uniqueness for security-v2 + // GG20 proof binding. Security-v2 keygen and signing require callers + // to coordinate a shared positive nonce before Start; legacy mode must + // leave it unset. sessionNonce *big.Int + // protocolMode is the explicit per-party proof-transcript mode. It has + // no default: callers must select legacy or security-v2 before + // constructing an ECDSA local party. + protocolMode ProtocolMode + protocolModeFrozen bool } ) const ( defaultSafePrimeGenTimeout = 5 * time.Minute + + // ProtocolModeLegacy reproduces the untagged GG20 proof transcript used + // before session binding was introduced. + ProtocolModeLegacy ProtocolMode = 1 + // ProtocolModeSecurityV2 requires and uses the session-bound, domain-tagged + // GG20 proof transcript. + ProtocolModeSecurityV2 ProtocolMode = 2 ) // Exported, used in `tss` client @@ -118,13 +136,61 @@ func (params *Parameters) SetSafePrimeGenTimeout(timeout time.Duration) { params.safePrimeGenTimeout = timeout } -// SessionNonce returns the optional per-session nonce used in proof challenges. +// ProtocolMode returns the explicit per-party proof-transcript mode. +func (params *Parameters) ProtocolMode() ProtocolMode { + return params.protocolMode +} + +// SetProtocolMode selects the proof transcript for the ECDSA local party that +// will be constructed from params. There is no implicit/default mode. +// +// A local party freezes this setting during construction. Changing it +// afterwards panics so an in-flight party can never switch transcripts. +func (params *Parameters) SetProtocolMode(mode ProtocolMode) { + if params.protocolModeFrozen { + panic("tss: protocol mode is immutable after local party construction") + } + switch mode { + case ProtocolModeLegacy, ProtocolModeSecurityV2: + default: + panic(fmt.Sprintf("tss: invalid protocol mode %d", mode)) + } + if params.protocolMode != 0 && params.protocolMode != mode { + panic("tss: protocol mode cannot be changed after selection") + } + params.protocolMode = mode +} + +// FreezeProtocolMode validates and freezes the transcript configuration. +// ECDSA local-party constructors call it before retaining params. +func (params *Parameters) FreezeProtocolMode() { + if params.protocolModeFrozen { + return + } + switch params.protocolMode { + case ProtocolModeLegacy: + if params.sessionNonce != nil { + panic("tss: legacy protocol mode must not set a session nonce") + } + case ProtocolModeSecurityV2: + default: + panic("tss: protocol mode must be selected before local party construction") + } + params.protocolModeFrozen = true +} + +// SessionNonce returns a defensive copy of the optional per-session nonce used +// in proof challenges. func (params *Parameters) SessionNonce() *big.Int { - return params.sessionNonce + if params.sessionNonce == nil { + return nil + } + return new(big.Int).Set(params.sessionNonce) } -// SetSessionNonce sets a per-session nonce that all parties in a protocol run -// must agree on. It must be called before Start. +// SetSessionNonce sets a per-session nonce that all security-v2 parties in a +// protocol run must agree on. It must be called before constructing the local +// party. Legacy parties must not set a nonce. // // Keygen and signing fail closed if no nonce is set. The previous zero // (keygen) and SHA512_256(messageBytes) (signing) fallbacks caused two @@ -132,9 +198,12 @@ func (params *Parameters) SessionNonce() *big.Int { // the session-binding property that the proofs rely on. The caller must supply // a per-ceremony unique nonce; reusing the same nonce across distinct // ceremonies on the same inputs reintroduces transcript-splicing risk. Set the -// nonce before Start on the same goroutine that constructs the party; do not -// mutate Parameters concurrently with a running protocol. +// nonce before constructing the party on the same goroutine; do not mutate +// Parameters concurrently with a running protocol. func (params *Parameters) SetSessionNonce(nonce *big.Int) { + if params.protocolModeFrozen { + panic("tss: session nonce is immutable after local party construction") + } if nonce == nil || nonce.Sign() <= 0 { panic("tss: session nonce must be positive") } diff --git a/tss/params_test.go b/tss/params_test.go index c9fed7a1..9320a718 100644 --- a/tss/params_test.go +++ b/tss/params_test.go @@ -26,6 +26,80 @@ func TestSetSessionNonceCopiesInput(t *testing.T) { assert.Equal(t, big.NewInt(42), params.SessionNonce()) } +func TestSessionNonceReturnsCopy(t *testing.T) { + pIDs := GenerateTestPartyIDs(2) + params := NewParameters(S256(), NewPeerContext(pIDs), pIDs[0], len(pIDs), 1) + params.SetSessionNonce(big.NewInt(42)) + + returned := params.SessionNonce() + returned.SetInt64(7) + + assert.Equal(t, big.NewInt(42), params.SessionNonce()) +} + +func TestProtocolModeMustBeExplicitAndImmutable(t *testing.T) { + pIDs := GenerateTestPartyIDs(2) + newParams := func() *Parameters { + return NewParameters( + S256(), + NewPeerContext(pIDs), + pIDs[0], + len(pIDs), + 1, + ) + } + + assert.Panics(t, func() { + newParams().FreezeProtocolMode() + }) + for _, invalid := range []ProtocolMode{0, 3, 255} { + assert.Panics(t, func() { + newParams().SetProtocolMode(invalid) + }) + } + + legacy := newParams() + legacy.SetProtocolMode(ProtocolModeLegacy) + assert.Equal(t, ProtocolModeLegacy, legacy.ProtocolMode()) + assert.Panics(t, func() { + legacy.SetProtocolMode(ProtocolModeSecurityV2) + }) + + legacy.FreezeProtocolMode() + assert.Panics(t, func() { + legacy.SetProtocolMode(ProtocolModeLegacy) + }) + assert.Panics(t, func() { + legacy.SetSessionNonce(big.NewInt(1)) + }) + + securityV2 := newParams() + securityV2.SetProtocolMode(ProtocolModeSecurityV2) + securityV2.SetSessionNonce(big.NewInt(1)) + securityV2.FreezeProtocolMode() + assert.Equal(t, ProtocolModeSecurityV2, securityV2.ProtocolMode()) + assert.Panics(t, func() { + securityV2.SetSessionNonce(big.NewInt(2)) + }) +} + +func TestLegacyProtocolModeRejectsSessionNonce(t *testing.T) { + pIDs := GenerateTestPartyIDs(2) + params := NewParameters( + S256(), + NewPeerContext(pIDs), + pIDs[0], + len(pIDs), + 1, + ) + params.SetProtocolMode(ProtocolModeLegacy) + params.SetSessionNonce(big.NewInt(1)) + + assert.Panics(t, func() { + params.FreezeProtocolMode() + }) +} + func TestSetSessionNonceBytesHashesSessionID(t *testing.T) { pIDs := GenerateTestPartyIDs(2) params := NewParameters(S256(), NewPeerContext(pIDs), pIDs[0], len(pIDs), 1)